@sap/cds 5.8.4 → 5.9.0

package/lib/env/requires.js

@@ -1,16 +1,21 @@
 const _runtime = '../../libx/_runtime'
 
-module.exports = {
-  "db": undefined,
-  "multitenancy": undefined,
-  "app-service": {
-    // this is the default implementation used for provided services
-    impl: `${_runtime}/cds-services/services/Service.js`
-  },
-  "auth": {
+exports = module.exports = {
+
+  db: undefined,
+  messaging: undefined,
+  multitenancy: undefined,
+
+  auth: {
     '[development]': { kind: 'mocked-auth' },
     '[production]': { kind: 'jwt-auth' }
   },
+
+}
+
+
+const _authentication_strategies = {
+
   "dummy-auth": {
     strategy: 'dummy',
   },
@@ -27,50 +32,66 @@ module.exports = {
   },
   "jwt-auth": {
     strategy: 'JWT',
+    vcap: { label: 'xsuaa' }
   },
-  "xsuaa-auth": {
+  "xsuaa": {
     strategy: 'xsuaa',
+    vcap: { label: 'xsuaa' }
   },
-  "dwc-auth": {
-    strategy: 'dwc',
+
+}
+
+
+const _services = {
+
+  "app-service": {
+    // this is the default implementation used for provided services
+    impl: `${_runtime}/cds-services/services/Service.js`
   },
-  destinations: {
-    vcap: {
-      label: 'destination'
-    }
+  "rest": {
+    impl: `${_runtime}/remote/Service.js`
   },
-  xsuaa: {
-    vcap: {
-      label: 'xsuaa'
-    }
+  "odata": {
+    impl: `${_runtime}/remote/Service.js`
+  },
+  "odata-v2": { // REVISIT: we should introduce .version
+    impl: `${_runtime}/remote/Service.js`
+  },
+  "odata-v4": { // REVISIT: we should introduce .version
+    impl: `${_runtime}/remote/Service.js`
   },
-  monitoring: undefined,
-  logging: undefined,
-  audit: undefined,
+
+}
+
+
+const _databases = {
+
   "sql": {
     '[development]': { kind: 'sqlite', credentials: { url: ':memory:' } },
     '[production]': { kind: 'hana' },
   },
   "sqlite": _compat_to_use({
-    dialect: 'sqlite', credentials: { url: 'sqlite.db' },
+    credentials: { url: 'sqlite.db' },
     impl: `${_runtime}/sqlite/Service.js`,
   }),
   "hana": _compat_to_use ({
-    dialect: 'hana',
     impl: `${_runtime}/hana/Service.js`,
   }),
-  "rest": {
-    impl: `${_runtime}/remote/Service.js`
-  },
-  "odata": {
-    impl: `${_runtime}/remote/Service.js`
-  },
-  "odata-v2": {
-    kind: 'odata'
-  },
-  "odata-v4": {
-    kind: 'odata'
-  },
+  "hana-cloud": _compat_to_use ({
+    kind: 'hana', "deploy-format": "hdbtable",
+  }),
+  "hana-mt": _compat_to_use ({
+    kind: 'hana', "deploy-format": "hdbtable",
+    "vcap": {
+      "label": "service-manager"
+    }
+  }),
+
+}
+
+
+const _messaging = {
+
   "local-messaging": {
     impl: `${_runtime}/messaging/service.js`,
     local: true
@@ -112,28 +133,78 @@ module.exports = {
   "composite-messaging": {
     impl: `${_runtime}/messaging/composite.js`
   },
-  "audit-log": {
+  "mtx-messaging": {
+    kind: "local-messaging",
+    "[production]": {
+      kind: "redis-messaging"
+    }
+  },
+  "redis-messaging": {
+    impl: `${_runtime}/messaging/redis-messaging.js`,
+    vcap: { label: "redis-cache" },
+    outbox: {}
+  },
+
+  "persistent-outbox": {
+    model: "@sap/cds/srv/outbox",
+    maxAttempts: 20,
+    chunkSize: 100
+  },
+
+}
+
+
+const _multitenancy = {
+}
+
+
+const _extensibility = {
+
+  "uiflex": {
+    model: "@sap/cds/srv/flex"
+  },
+
+}
+
+
+
+const _platform_services = {
+
+  "audit-log-service": {
     impl: `${_runtime}/audit/Service.js`,
-    // REVISIT: how to load model? -> see _prototypes below
     // model: 'AuditLogService.cds',
     outbox: {},
     vcap: { label: "auditlog" },
   },
 
-  _prototypes: {
-    "uiflex": {
-      model: "@sap/cds/srv/flex"
-    },
-    "persistent-outbox": {
-      model: "@sap/cds/srv/outbox",
-      maxAttempts: 20,
-      chunkSize: 100
-    },
-  }
+  "audit-log-to-console": {
+    kind: "audit-log-service",
+    credentials: { logToConsole: true }
+  },
+
+  destinations: {
+    vcap: {
+      label: 'destination'
+    }
+  },
+
+  approuter: undefined,
+
+}
+
+
+exports.kinds = {
+  ..._authentication_strategies,
+  ..._databases,
+  ..._services,
+  ..._messaging,
+  ..._multitenancy,
+  ..._extensibility,
+  ..._platform_services,
 }
 
 
 function _compat_to_use(o) { return Object.defineProperties (o,{
   // NOTE: Property .use is for compatibility only -> use .dialect instead!
-  use: { get(){ return this.dialect }, enumerable:true },
+  use: { get(){ return this.dialect || this.kind }, configurable:true, enumerable:true },
 })}

package/lib/index.js

@@ -81,6 +81,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]) => {