@sap/cds 5.8.4 → 5.9.2

package/lib/index.js

@@ -12,6 +12,7 @@ if (global.cds) Object.assign(module,{exports:global.cds}) ; else {
       /** @type {{ [path:string] : Service }} */ paths: {},
       /** @type Service[] */ providers: [],
       factory: require ('./serve/factory'),
+      adapters: require ('./serve/adapters'),
       bindings: require ('./connect/bindings'),
     })}
     /** @type {import './req/context'} */
@@ -81,6 +82,7 @@ if (global.cds) Object.assign(module,{exports:global.cds}) ; else {
     MessagingService: lazy => require('../libx/_runtime/messaging/service.js'),
     DatabaseService: lazy => require('../libx/_runtime/db/Service.js'),
     RemoteService: lazy => require('../libx/_runtime/rest/service.js'),
+    AuditLogService: lazy => require('../libx/_runtime/audit/Service.js'),
     odata: require('../libx/odata'),
 
     // Helpers

package/lib/log/format/kibana.js

@@ -1,4 +1,4 @@
-const cds = require('../../')
+const cds = require ('../../')
 const util = require('util')
 
 const _l2l = { 1: 'error', 2: 'warn', 3: 'info', 4: 'debug', 5: 'trace' }
@@ -8,7 +8,7 @@ const _l2l = { 1: 'error', 2: 'warn', 3: 'info', 4: 'debug', 5: 'trace' }
  */
 module.exports = (module, level, ...args) => {
   // config
-  const { user: log_user, kibana_custom_fields } = cds.env.log
+  const { user: log_user , kibana_custom_fields } = cds.env.log
 
   // build the object to log
   const toLog = {

package/lib/ql/SELECT.js

@@ -40,6 +40,16 @@ module.exports = class SELECT extends Whereable {
       if (cols === '*') return this.columns(...arguments)
       const c = _columns_or_not (cols)
       if (c) return this._add('columns',c)
+      if (typeof cols === 'string') {
+        try { parse.path(cols) }
+        catch(e) { //> it can't be a from
+          try { return this.columns(...arguments) }
+          catch(e) {
+            if (!e.message.startsWith('CDS compilation failed')) throw e
+            this._expected `Argument ${{cols}} to be a valid argument for SELECT.from or .columns`
+          }
+        }
+      }
     }
 
     // return a proxy assuming it's a from and switching to

package/lib/ql/parse.js

@@ -7,6 +7,7 @@ module.exports = {
   CQL: (..._) => cds.parse.CQL (..._),
   CXL: (..._) => cds.parse.CXL (..._),
   cql: (..._) => cds.parse.cql (..._),
+  path: (..._) => cds.parse.path (..._),
 }
 
 const _simple = (x) => {

package/lib/req/cds-context.js

@@ -21,7 +21,10 @@ const { EventEmitter } = require('events')
     Reflect.defineProperty (cds,'context',{ enumerable:1,
       set(v) {
         const cr = current(); if (!cr) return
-        const ctx = typeof v !== 'object' ? v : v.context || (v instanceof EventContext ? v : EventContext.for(v,false))
+        const ctx = (
+          v instanceof EventContext || typeof v !== 'object' ? v :
+          v.context || EventContext.for (v.req ? {_:v} : v)
+        )
         cr[_context] = ctx
       },
       get() {

package/lib/req/context.js

@@ -1,5 +1,6 @@
 const cds = require ('../index'), { features } = cds.env, { uuid } = cds.utils
 const async_events = { succeeded:1, failed:1, done:1 }
+const req_locale = require('./locale')
 const { EventEmitter } = require('events')
 
 /**
@@ -10,31 +11,23 @@ const { EventEmitter } = require('events')
  */
 class EventContext {
 
-  toString() { return `${this.event} ${this.path}` }
-
-  static for (data={}, base = cds.context) {
-    if (data instanceof EventContext) return data
-    if (base && features.cds_tx_inheritance) {
-      let u = _inherit('user', u => typeof u === 'object' ? Object.create(u) : u)
-      if (!u || !u.tenant) _inherit('tenant')
-      if (!u || !u.locale) _inherit('locale')
-    }
-    function _inherit (p,fn) {
-      if (p in data) return data[p]
-      let pd = Reflect.getOwnPropertyDescriptor(base,p); if (!pd) return
-      return data[p] = fn ? fn(pd.value) : pd.value
+  /** Creates a new instance that inherits from cds.context */
+  static for (_) {
+    const ctx = new this (_)
+    if (features.cds_tx_inheritance) {
+      const base = cds.context
+      if (base) ctx._set('_propagated', base)
     }
-    // IMPORTANT: ensure user is first to be assigned to call setter_
-    if (data.user) data = { user:1, ...data }
-    return new this (data)
+    return ctx
   }
 
   constructor(_={}) {
-    Object.assign (this, this._set('_',_))
+    Object.defineProperty (this, '_', { value:_, writable:true })
+    Object.assign (this, _)
   }
 
   _set (property, value) {
-    Object.defineProperty (this, property, {value,writable:true})
+    Object.defineProperty (this, property, { value, writable:true })
     return value
   }
 
@@ -44,18 +37,16 @@ class EventContext {
   // Emitting and listening to succeeded / failed / done events
   //
 
-  /** @returns {EventEmitter} */ get emitter() {
-    return this._emitter || (this._emitter = this._propagated('emitter') || new EventEmitter)
+  get emitter() {
+    return this.context._emitter || (this.context._emitter = new EventEmitter)
   }
 
   async emit (event,...args) {
-    if (!this._emitter) return
-    if (event in async_events) {
-      for (const each of this._emitter.listeners(event)) {
-        await each.call(this,...args)
-      }
-    }
-    else return this._emitter.emit (event,...args)
+    const emitter = this.context._emitter; if (!emitter) return
+    if (event in async_events)
+      for (const each of emitter.listeners(event))
+        await each.call (this, ...args)
+    else return emitter.emit (event,...args)
   }
 
   on (event, listener) {
@@ -75,48 +66,58 @@ class EventContext {
   // The following properties are inherited from root contexts, if exist...
   //
 
-  set context(c) { if (c) this._set('context',c) }
+  set context(c) { if (c) this._set('context', this._set('_propagated', c)) }
   get context() { return this }
 
-  set id(c) { if (c) super.id = c }
+  set id(id) {
+    if (id) super.id = id
+  }
   get id() {
-    return this.id = this._propagated('id') || this.headers[ 'x-correlation-id' ] || uuid()
+    return super.id = this._propagated.id || this.headers[ 'x-correlation-id' ] || uuid()
   }
 
   set tenant(t) {
-    if (t) super.tenant = this.user.tenant = t
+    if (t) super.tenant = t
   }
   get tenant() {
-    return this.tenant = this.user.tenant || this._propagated('tenant')
+    return super.tenant = this._propagated.tenant
   }
 
   set user(u) {
-    if (!u) return
-    if (typeof u === 'string') u = new cds.User(u)
-    if (this._.req) Object.defineProperty(u,'_req',{value:this._.req}) // REVISIT: The following is to support req.user.locale
-    super.user = u
+    const user = super.user = u instanceof cds.User ? u : new cds.User(u)
+    for (let p of ['tenant','locale']) { // compatibility
+      if (u && u.hasOwnProperty(p)) this[p] = u[p] // eslint-disable-line no-prototype-builtins
+      else Object.defineProperty (user, p, { get: () => this[p] })
+    }
   }
   get user() {
-    return this.user = this._propagated('user') || new cds.User
+    const u = this._propagated.user
+    return this.user = u ? {__proto__:u} : new cds.User.default
   }
 
   set locale(l) {
-    if (l) super.locale = this.user.locale = l
+    if (l) super.locale = super._locale = l
   }
   get locale() {
-    return this.locale = this.user.locale || this._propagated('locale')
+    return super.locale = this._propagated.locale || req_locale(this._.req)
+  }
+  get _locale() {
+    return super._locale = this._propagated._locale || req_locale.from_req(this._.req)
+    || this.hasOwnProperty('locale') && this.locale // eslint-disable-line no-prototype-builtins
   }
 
   get timestamp() {
-    return super.timestamp = this._propagated('timestamp') || new Date
+    return super.timestamp = this._propagated.timestamp || new Date
   }
 
-  set headers(h) { if (h) super.headers = h }
+  set headers(h) {
+    if (h) super.headers = h
+  }
   get headers() {
     if (this._ && this._.req && this._.req.headers) {
       return super.headers = this._.req.headers
     } else {
-      const headers={}, outer = this._propagated('headers')
+      const headers={}, outer = this._propagated.headers
       if (outer) for (let each of EventContext.propagateHeaders) {
         if (each in outer) headers[each] = outer[each]
       }
@@ -125,27 +126,18 @@ class EventContext {
   }
 
 
-  //
-  // Connecting to transactions and request hierarchies
-  //
-
-  _propagated (p) {
-    const ctx = this.context
-    if (ctx !== this) return ctx[p]
-  }
-
   set _tx(tx) {
     Object.defineProperty (this,'_tx',{value:tx}) //> allowed only once!
     const ctx = tx.context
     if (ctx && ctx !== this) {
-      this.context = ctx
+      if (!this.hasOwnProperty('context')) this.context = ctx // eslint-disable-line no-prototype-builtins
+      ///////////////////////////////////////////////////////////////////
       // REVISIT: Eliminate req._children
-      // only collect children if integrity checks are active
       if (features.assert_integrity !== false) {
-        const reqs = ctx._children || (ctx._children = {})
+        const reqs = ctx._children || ctx._set('_children', {})
         const all = reqs[tx.name] || (reqs[tx.name] = [])
         all.push(this)
-      }
+      } //////////////////////////////////////////////////////////////////
     }
   }
 
@@ -153,9 +145,11 @@ class EventContext {
   /** REVISIT: remove -> @deprecated */
   set _model(m){ super._model = m }
   get _model() {
-    return super._model = this._tx && this._tx.model || this._propagated('_model')
+    return super._model = this._tx && this._tx.model || this._propagated._model
   }
 }
 
+
+EventContext.prototype._set('_propagated', Object.seal({}))
 EventContext.propagateHeaders = [ 'x-correlation-id' ]
 module.exports = EventContext

package/lib/req/event.js

@@ -4,12 +4,7 @@ const EventContext = require ('./context')
  * Instances of class cds.Event represent asynchronous messages as well as
  * synchronous requests. The latter are instances of subclass cds.Request.
  */
-class EventMessage extends EventContext {
-  static for (eve) {
-    if (eve instanceof this) return eve
-    if (typeof eve === 'object') return new this(eve)
-  }
-}
+class EventMessage extends EventContext {}
 
 module.exports = exports = EventMessage
 exports.Context = EventContext

package/lib/req/locale.js

@@ -7,15 +7,16 @@ const INCLUDE_LIST = i18n.preserved_locales.reduce((p,n)=>{
   en_US_x_sappsd: 'en_US_sappsd'
 })
 
-const from_req = req => req.query['sap-language'] || req.headers['x-sap-request-language'] || req.headers['accept-language']
+const from_req = req => req && (
+  req.query && req.query['sap-language'] ||
+  req.headers && (req.headers['x-sap-request-language'] || req.headers['accept-language'])
+)
 
 function req_locale (req) {
-  if (!req) return i18n.default_language
-  const locale = from_req(req)
-  if (!locale) return i18n.default_language
+  const locale = from_req(req); if (!locale) return i18n.default_language
   const loc = locale.replace(/-/g,'_')
   return INCLUDE_LIST[loc]
-  || /([a-z]+)/i.test(loc) && RegExp.$1.toLowerCase()
+  || /^([a-z]+)/i.test(loc) && RegExp.$1.toLowerCase()
   || i18n.default_language
 }
 

package/lib/req/request.js

@@ -7,6 +7,8 @@ const { Responses, Errors } = require('./response')
  */
 class Request extends require('./event') {
 
+  toString() { return `${this.event} ${this.path}` }
+
   set method(m) { if (m) super.method = m }
   get method() {
     return this._set ('method', Crud2Http[this.event] || this.event)

package/lib/req/user.js

@@ -1,5 +1,3 @@
-const req_locale = require('./locale')
-
 class User {
 
   constructor (_) {
@@ -9,9 +7,6 @@ class User {
     if (Array.isArray(_._roles)) this._roles = _._roles.reduce((p,n)=>{p[n]=1; return p},{})
   }
 
-  get locale() { return super.locale = req_locale (this._req) }
-  set locale(l) { if (l) super.locale = l }
-
   get attr() { return super.attr = {} }
 
   get _roles(){ return super._roles = {
@@ -24,6 +19,9 @@ class User {
 
 }
 
+/**
+ * Subclass representing non-identified unauthenticated users.
+ */
 class Anonymous extends User {
   is (role) { return role === 'any' }
   get _roles() { return {} }
@@ -31,6 +29,9 @@ class Anonymous extends User {
 Anonymous.prototype._is_anonymous = true
 Anonymous.prototype.id = 'anonymous'
 
+/**
+ * Subclass for executing code with superuser privileges.
+ */
 class Privileged extends User {
   constructor(_) { super(_||{}) }
   is() { return true }
@@ -38,4 +39,5 @@ class Privileged extends User {
 Privileged.prototype._is_privileged = true
 Privileged.prototype.id = 'privileged'
 
+// exports -----------------
 module.exports = exports = Object.assign (User, { Anonymous, Privileged, default:Anonymous })

package/lib/serve/Service-api.js

@@ -1,5 +1,6 @@
+const cds = require('..'), { Event, Request } = cds
 const add_methods_to = require ('./Service-methods')
-const cds = require('..'), { unfold_csn: cds_localized } = cds.compile._localized
+const { unfold_csn: cds_localized } = cds.compile._localized
 
 
 class Service extends require('./Service-handlers') {
@@ -15,7 +16,7 @@ class Service extends require('./Service-handlers') {
    */
   set model (csn) {
     if (csn) {
-      super.model = cds_localized(cds.linked(cds.compile.for.odata(csn)))
+      super.model = cds.compile.for.nodejs(csn)
       add_methods_to (this)
     } else {
       super.model = undefined
@@ -27,7 +28,9 @@ class Service extends require('./Service-handlers') {
    */
   emit (event, data, headers) {
     const res = this._compat_sync (event, data, headers); if (res) return res
-    const eve = cds.Event.for(event) || new cds.Event({ event, data, headers })
+    const eve = event instanceof Event ? event : new Event (
+      is_object(event) ? event : { event, data, headers }
+    )
     return this.dispatch (eve)
   }
 
@@ -35,9 +38,8 @@ class Service extends require('./Service-handlers') {
    * REST-style API to send synchronous requests...
    */
   send (method, path, data, headers) {
-    const req = cds.Request.for(method) || (
-      typeof path === 'object' ? new cds.Request({ method, data:path, headers:data }) :
-      new cds.Request({ method, path, data, headers })
+    const req = method instanceof Request ? method : new Request (
+      is_object(method) ? method : is_object(path) ? { method, data:path, headers:data } : { method, path, data, headers }
     )
     return this.dispatch (req)
   }
@@ -51,7 +53,7 @@ class Service extends require('./Service-handlers') {
    * Querying API to send synchronous requests...
    */
   run (query, data) {
-    const req = new cds.Request ({ query, data })
+    const req = new Request ({ query, data })
     return this.dispatch (req)
   }
   read   (...args) { return is_query(args[0]) ? this.run(...args) : SELECT(...args).bind(this) }
@@ -113,3 +115,4 @@ const _reflect = (srv,filter) => !srv.model ? [] : srv.model.childrenOf (srv.nam
 const is_rest = x => x && typeof x === 'string' && x[0] === '/'
 const is_query = x => x && x.bind || is_array(x) && !x.raw
 const is_array = (x) => Array.isArray(x) && !x.raw
+const is_object = (x) => typeof x === 'object'

package/lib/serve/Service-dispatch.js

@@ -13,12 +13,12 @@ exports.dispatch = async function dispatch (req) { //NOSONAR
 
   // Ensure we are in a proper transaction
   if (!this.context) {
-    const txc = cds.context //> join an outer tx.context, if any, with a nested tx
-    if (txc && !txc._done) return this.tx(txc).dispatch(req)
-    else try {    //>  start a new top-level tx, which we need to commit/rollback
-      const tx = cds.context = this.tx(req)
-      return tx.dispatch(req) .then (tx.commit, tx.rollback)
-    } finally { cds.context = txc }
+    const ctx = cds.context
+    if (ctx && ctx._tx && !ctx._done) { // join outer context with a nested tx -> we don't modify outer context
+      return this.tx(ctx).dispatch(req)
+    } else { // start a new root tx for subsequent continuation
+      return this.tx(tx => (cds.context=tx).dispatch(req))
+    }
   }
   // `this` is a tx from now on...
   if (!req._tx) req._tx = this
@@ -97,7 +97,7 @@ const _is_array = Array.isArray
 const _dummy = ()=>{} // REVISIT: required for some messaging tests which obviously still expect and call next()
 
 const _ensure_target = (srv,req) => {
-  const q = req.query, p = req._.path; if (!q && !p) return
+  const q = req.query, p = req._.path || req._.entity; if (!q && !p) return
   if (srv.namespace) { // ensure fully-qualified names
     if (p) _ensure_fqn (req,'path',srv, p.startsWith('/') ? p.slice(1) : p)
     else if (q.SELECT) _ensure_fqn (q.SELECT,'from',srv)
@@ -105,10 +105,8 @@ const _ensure_target = (srv,req) => {
     else if (q.UPDATE) _ensure_fqn (q.UPDATE,'entity',srv)
     else if (q.DELETE) _ensure_fqn (q.DELETE,'from',srv)
   }
-  if (typeof q === 'object') {
-    const m = srv.model, defs = m && m.definitions || {}
-    req.target = cds.infer(q,defs)
-  }
+  const m = srv.model, defs = m && m.definitions || {}
+  req.target = typeof q === 'object' ? cds.infer(q,defs) : defs[req.path]
 }
 
 const _ensure_fqn = (x,p,srv, name = x[p]) => {

package/lib/serve/Service-methods.js

@@ -12,53 +12,42 @@ module.exports = (srv) => {
 
 const add_handler_for = (srv, def) => {
   const event = def.name.match(/\w*$/)[0]
+
+  // Use existing methods as handler implementations
   const method = srv[event]
   if (method) {
-    // use existing method as handler
-    if (method._handled || method.name in srv.__proto__) return
-    srv.on (event, ({data}) => {
+    if (method._is_stub || method.name in srv.__proto__.__proto__) return
+    srv.on (event, function ({params,data}) {
       const args = []; if (def.parent) args.push (def.parent)
+      for (let p in params) args.push(params[p])
       for (let p in data) args.push(data[p])
-      return method.apply (srv,args)
+      return method.apply (this,args)
     })
-    method._handled = true
-  } else {
-    // add method to emit request
-    const method = srv[event] = function (...args) {
-      const [$] = args, target = this.entities [ $ && $.name ? $.name.match(/\w*$/)[0] : $ ]
-      const data = {}
-      if (target) { //> it's a bound action
-        def = target.actions[event]; args.shift()
-        // In case of bound actions, first argument(s) are expected to be the target's primary key,
-        // which we need to fill in to named properties in data
-        // object variant of keys, ensure keys are present in args[0] because of complex param
-        if (typeof args[0] === 'object' && Object.keys(target.keys).every(k => k in args[0])) {
-          const keys = args.shift()
-          for (const p in target.keys)  {
-            data[p] = keys[p]
-          }
-        } else { // positional
-          for (let p in target.keys)  {
-            data[p] = args.shift()
-          }
-        }
-        
-      }
-
-      // object variant of params, ensure at least one param is present in args[0]
-      // REVISIT: still not bullet proof, but parameters might be optional
-      if (def.params) {
-        if (args[0] !== null && typeof args[0] === 'object' && args.length === 1 && Object.keys(def.params).some(p => p in args[0])) {
-          const params = args.shift()
-          for (const p in def.params) data[p] = params[p]
-        } else { // positional
-          for (let p in def.params) data[p] = args.shift()
-        }
-      }
+  }
 
-      // REVISIT: What happens with name clashes of keys and params?
-      return this.send ({ event, target, data })
+  // Add stub methods to send request via typed API
+  const stub = srv[event] = function (...args) {
+    const req = { event, data:{} }, $ = args[0]
+    const target = this.entities [ $ && $.name ? $.name.match(/\w*$/)[0] : $ ]
+    if (target) {                        //> bound action/function?
+      req.target = target; args.shift() // first argument is the target entity name
+      req.params = [ args.shift() ]    // second argument is the target's primary key
     }
-    method._handled = true
+    const {params} = target ? target.actions[event] : def
+    if (params) req.data =  _named(args,params) || _positional(args,params)
+    return this.send (req)
   }
+  stub._is_stub = true
 }
+
+
+const _named = (args, declared) => {
+  if (args.length > 1) return
+  const a = args[0]
+  if (! a || typeof a !== 'object') return
+  if (Object.keys(a).every (k => k in declared)) return a
+}
+
+const _positional = (args, declared) => Object.keys(declared).reduce (
+  (data,k,i) => { data[k] = args[i]; return data }, {}
+)

package/lib/serve/Transaction.js

@@ -1,5 +1,7 @@
 const cds = require('../index'), { cds_tx_protection } = cds.env.features
 const EventContext = require('../req/context')
+class RootContext extends EventContext {}
+
 
 /**
  * This is the implementation of the `srv.tx(req)` method. It constructs
@@ -28,12 +30,10 @@ module.exports = function tx (ctx,fn) { const srv = this
   // `ctx` is a plain context object or undefined
   if (ctx) { // REVISIT: This is for compatibility with AFC only
     if (ctx._txed_before) return NestedTransaction.for (srv, ctx._txed_before)
-    else {
-      Object.defineProperty(ctx, '_txed_before', { value: EventContext.for(ctx) }) // > must be non-enumerable
-      return RootTransaction.for (srv, ctx._txed_before)
-    }
+    else Object.defineProperty(ctx, '_txed_before', { value: RootContext.for(ctx) }) // > must be non-enumerable
+    return RootTransaction.for (srv, ctx._txed_before)
   }
-  return RootTransaction.for (srv, EventContext.for(ctx))
+  return RootTransaction.for (srv, RootContext.for(ctx))
 }
 
 
@@ -174,8 +174,11 @@ const _begin = async function (req) {
     return this.ready = this.__proto__.dispatch.call (this,req)
   // Protection against unintended tx.run() after tx.commit/rollback()
   if (typeof this.ready === 'string' || !this.ready && this.context._done) {
-    if (cds_tx_protection) throw Object.assign(new Error (`Transaction is ${this.ready || this.context._done}, no subsequent .run allowed, without prior .begin`), { code: 'TRANSACTION_CLOSED' })
-    else this.ready = this.begin() // compatibiliy to former behavior, which allowed tx.run() after commit/rollback
+    if (!cds_tx_protection) this.ready = this.begin() // compatibiliy to former behavior, which allowed tx.run() after commit/rollback
+    else throw cds.error (
+      `Transaction is ${this.ready || this.context._done}, no subsequent .run allowed, without prior .begin`,
+      { code: 'TRANSACTION_CLOSED' }
+    )
   }
   else if (!this.ready) this.ready = this.begin()
   await this.ready

package/lib/serve/adapters.js

@@ -1,16 +1,18 @@
 const lib = require('../../libx/_runtime')
 const registry = {
-  rest: lib.to.rest,
-  odata: lib.to.odata_v4,
-  odata_v2: lib.to.odata_v4,
-  odata_v4: lib.to.odata_v4,
-  fiori: lib.to.odata_v4,
+  get rest() { return lib.to.old_rest },
+  get new_rest() { return lib.to.new_rest },
+  get odata() { return lib.to.odata_v4 },
+  get odata_v2() { return lib.to.odata_v4 },
+  get odata_v4() { return lib.to.odata_v4 },
+  get fiori() { return lib.to.odata_v4 },
 }
 
 
 class ProtocolAdapter {
 
   static at (protocol) {
+    if (protocol === 'rest' && global.cds.env.features.rest_new_adapter) protocol = 'new_rest'
     const factory = registry[protocol]; if (factory) return factory
     else throw new Error (`Service protocol ${protocol} is not supported`)
   }
@@ -30,12 +32,12 @@ class ProtocolAdapter {
   /**
   * Mounts the adapter to an express app.
   */
-  in (app) {
-    const srv = this.service
+  in (app, at) {
+    const srv = this.service, path = at || srv.path
     lib.perf (app)
     lib.auth (srv, app, srv.options)
-    app.use (srv.path+'/webapp/', (_,res)=> res.sendStatus(404))
-    app.use (srv.path, this)
+    app.use (path+'/webapp/', (_,res)=> res.sendStatus(404))
+    app.use (path, this)
     return srv
   }