@sap/cds 5.9.8 → 6.0.3

package/lib/req/assert.js

@@ -0,0 +1,71 @@
+const cds = require ('../index'), $ = cds.error.message
+
+module.exports = (req) => (field) => {
+
+  const def = field.name ? field : field.split('.').reduce (
+    (target,e) => target.elements[e] || cds.error `There's no element '${e}' in ${target}`,
+    req.target
+  )
+  return {
+
+    isSpecified (_msg) {
+      return this.validate ('MANDATORY_VALUE', this.data != undefined,
+        _msg, ()=> $`Value has to be filled in.`
+      )
+    },
+
+    isInRange (range, _msg) {
+      let data = this.data; if (data == undefined) return true
+      return this.validate ('VALUE_IN_RANGE',
+        !range ? data in def.enum : data >= range[0] && data <= range[1],
+        _msg, ()=> $`Value has to be in range ${range || Object.keys(def.enum)}.`
+      )
+    },
+
+    matches (pattern, _msg) {
+      let data = this.data; if (data == undefined) return true
+      let re = typeof pattern === 'string' ? RegExp(pattern) : pattern
+      return this.validate ('VALUE_MATCHING_PATTERN', re.test(data),
+        _msg, ()=> $`Value has to match ${re}`
+      )
+    },
+
+    meets (code, constraint, _msg) {
+      if (typeof code === 'function') [code,constraint,_msg] = ['CONSTRAINT',code,constraint]
+      let data = this.data; if (data == undefined) return true
+      let ok = constraint(data)
+      let validate = ok => this.validate(code,ok,_msg, ()=> `Value failed to meet ${constraint}`)
+      return typeof ok.then === 'function' ? ok.then(validate) : validate(ok)
+    },
+
+    async exists (_msg) {
+      let data = req.target.data(req.data), ref = def.refIn(data); if (ref == undefined) return true
+      return this.validate ('TARGET_EXISTS', await req.tx.exists(ref).forUpdate(),
+        _msg, ()=> $`Record ${def.target} with ${data[def.name]} doesn't exist.`
+      )
+    },
+
+    validate: (code, ok, _msg, message) => ok || req.error ({
+      code: 'FAILED_'+code, target: def.name,
+      message: _msg || message()
+    }),
+
+    get data(){ return def.dataIn(req.data) },
+    get to(){ return {__proto__:this,
+      get match(){ return this.matches },
+      get exist(){ return this.exists },
+      get meet(){ return this.meets },
+      get be(){ return {__proto__:this,
+        get specified(){ return this.isSpecified },
+        get inRange(){ return this.isInRange },
+        get in(){ return {__proto__:this,
+          get range(){ return this.isInRange },
+        }}
+      }}
+    }},
+    get not(){ return {__proto__:this, validate:(c,ok,m,$) => this.validate(
+      c, !ok, m, ()=> $().replace(/must|has to/,'must not')
+    )}},
+
+  }
+}

package/lib/req/cds-context.js

@@ -1,82 +1,50 @@
-const cds = require('../index'), { EventContext } = cds
+const { AsyncLocalStorage } = require ('async_hooks')
 const { EventEmitter } = require('events')
+const EventContext = require('./context')
 
+module.exports = new class extends AsyncLocalStorage {
 
-/**
- * Continuation Local Storage for cds.context
- */
- exports.for = (cds,v) => {
+  run(v,fn,...args) { return super.run (this._context4(v),fn,...args) }
+  enterWith(v) { return super.enterWith (this._context4(v)) }
 
-  if (cds.env.features.cls) {
-
-    const { executionAsyncResource:current, createHook } = module.require ('async_hooks')
-    const _context = Symbol('cds.context')
-
-    createHook ({ init(id,t,tid, res) {
-      const cr = current(); if (!cr) return
-      const ctx = cr[_context]
-      if (ctx) res[_context] = ctx
-    }}).enable()
-
-    Reflect.defineProperty (cds,'context',{ enumerable:1,
-      set(v) {
-        const cr = current(); if (!cr) return
-        const ctx = (
-          v instanceof EventContext || typeof v !== 'object' ? v :
-          v.context || EventContext.for (v.req ? {_:v} : v)
-        )
-        cr[_context] = ctx
-      },
-      get() {
-        const cr = current(); if (!cr) return undefined
-        return cr[_context]
-      },
-    })
-
-  } else {
+  _context4(v) {
+    if (v instanceof EventContext || typeof v !== 'object') return v
+    if (v.context) return v.context
+    if (v.req) v = v.res ? {http:v} : {http:{ ...v, res: v.req.res }}
+    return EventContext.for(v)
+  }
 
-    Reflect.defineProperty (cds,'context',{ enumerable:1,
+  /** @returns {EventContext} */
+  _for (cds,v) {
+    Reflect.defineProperty (cds,'context', { enumerable:1, ... cds.env.features.cls ? {
+      set:(v) => this.enterWith(v),
+      get:()=> this.getStore(),
+    } : {
       get:()=> undefined,
       set:()=> {},
-    })
-
+    }})
+    return cds.context = v // IMPORTANT: we need to set it initially, to get it all wired up correctly
   }
 
-  return v ? cds.context = v : cds.context
-}
-
-
-
-exports.spawn = function cds_spawn (o,fn) {
-
-  if (typeof o === 'function') [fn,o] = [o,fn] //> for compatibility
-  if (o instanceof cds.EventContext) throw new Error('The passed options must not be an instance of cds.EventContext.')
-  else if (!o) o = {}
-
-  const em = new EventEmitter()
-  const fx = () => {
-    // create a new transaction for each run of the background job
-    // which inherits from the current event context by default
-    const o2 = { ...o }; delete o2.timestamp //> spawned txes set their own timestamps
-    const tx = cds.context = cds.tx(o2)
-    const commit = async (res) => {
-      await tx.commit()
-      for (const handler of em.listeners('succeeded')) await handler(res)
-      for (const handler of em.listeners('done')) await handler()
+  spawn (o,fn, /** @type {import('../index')} cds */ cds=this) {
+    if (typeof o === 'function') [fn,o] = [o,fn] //> for compatibility
+    if (o instanceof EventContext) throw cds.error `The passed options must not be an instance of cds.EventContext.`
+    const fx = ()=>{
+      const tx = cds.tx({...o}) // create a new detached transaction for each run of the background job
+      return cds._context.run (tx, ()=> Promise.resolve(fn(tx))
+        .then (tx.commit, e => tx.rollback(_error(e, cds)))
+        .then (res => Promise.all(em.listeners('succeeded').map(each => each(res))))
+        .catch (err => Promise.all(em.listeners('failed').map(each => each(err))))
+        .finally (() => Promise.all(em.listeners('done').map(each => each())))
+      )
     }
-    Promise.resolve().then(() => fn(tx)).then(commit, tx.rollback) .catch (async e => {
-      // tx.rollback throws passed error -> we will arrive here for any error
-      cds.log().error(`ERROR occured in background job:`, e)
-      for (const handler of em.listeners('failed')) await handler(e)
-      for (const handler of em.listeners('done')) await handler()
-    })
+    const em = new EventEmitter; em.timer = (
+      (o && o.after) ? setTimeout(fx, o.after) :
+      (o && o.every) ? setInterval(fx, o.every) :
+      setImmediate(fx)
+    )
+    return em
   }
-
-  const timer = (
-    (o && o.after) ? setTimeout(fx, o.after) :
-    (o && o.every) ? setInterval(fx, o.every) :
-    setImmediate(fx)
-  )
-
-  return Object.assign (em, { timer })
 }
+
+const _error = (err, cds) => { cds.log().error(`ERROR occured in background job:`, err); return err }

package/lib/req/context.js

@@ -1,5 +1,5 @@
 const cds = require ('../index'), { features } = cds.env, { uuid } = cds.utils
-const async_events = { succeeded:1, failed:1, done:1 }
+const async_events = { succeeded:1, failed:1, done:1, commit:1 }
 const req_locale = require('./locale')
 const { EventEmitter } = require('events')
 
@@ -84,15 +84,13 @@ class EventContext {
   }
 
   set 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] })
-    }
+    const user = u instanceof cds.User ? u : new cds.User(u)
+    if (u && typeof u === 'object') for (let p in _TENANT_LOCALE) if (p in u && u[p]) this[p] = u[p]
+    super.user = new Proxy (user,{ get:(t,p) => p in _TENANT_LOCALE ? this[p] : t[p] })
   }
   get user() {
-    const u = this._propagated.user
-    return this.user = u ? {__proto__:u} : new cds.User.default
+    this.user = this._propagated.user || _anonymous
+    return this.user // IMPORTANT: first set this.user then return it separately to ensure we return the compat-wrapped objects
   }
 
   set locale(l) {
@@ -114,41 +112,56 @@ class EventContext {
     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
+    let headers = this._.req?.headers
+    if (!headers) { headers={}
+      const outer = this._propagated.headers
       if (outer) for (let each of EventContext.propagateHeaders) {
         if (each in outer) headers[each] = outer[each]
       }
-      return super.headers = headers
     }
+    return super.headers = headers
+  }
+
+  set http(rr) {
+    if (!this._.req) Object.assign(this._, rr)
+    super.http = rr
+  }
+  get http() {
+    return this._propagated.http || this._.req && this._.res && { req:this._.req, res:this._.res }
   }
 
 
-  set _tx(tx) {
-    Object.defineProperty (this,'_tx',{value:tx}) //> allowed only once!
+  /**
+   * This sets an EventContext's / Message's / Request's tx object, i.e.
+   * the service which this request is passed on for execution.
+   * In response to that, the instance will be wired up to and inherit
+   * context properties from tx.context.
+   */
+  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
-      ///////////////////////////////////////////////////////////////////
-      // REVISIT: Eliminate req._children
-      if (features.assert_integrity !== false) {
+
+      if (features.assert_integrity && features.assert_integrity_type == 'RT') {
         const reqs = ctx._children || ctx._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){ super._model = m }
+  set _model(m){ Object.defineProperty(this,'_model',{value:m}) }
   get _model() {
-    return super._model = this._tx && this._tx.model || this._propagated._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
 
 EventContext.prototype._set('_propagated', Object.seal({}))
 EventContext.propagateHeaders = [ 'x-correlation-id' ]

package/lib/req/request.js

@@ -9,6 +9,8 @@ class Request extends require('./event') {
 
   toString() { return `${this.event} ${this.path}` }
 
+  get assert(){ return super.assert = require('./assert')(this) }
+
   set method(m) { if (m) super.method = m }
   get method() {
     return this._set ('method', Crud2Http[this.event] || this.event)
@@ -33,27 +35,23 @@ class Request extends require('./event') {
 
   set path(p) { if (p) super.path = p.startsWith('/') ? p.slice(1) : p }
   get path() {
-    const {_} = this
-    if (this.query) { // IMPORTANT: Bulk queries don't have a _.query
-      const q = this.query
+    const q = this.query; if (this.query) { // IMPORTANT: Bulk queries don't have a _.query
       if (q.SELECT) return this._set ('path', _path4 (q.SELECT,'from'))
       if (q.INSERT) return this._set ('path', _path4 (q.INSERT,'into'))
       if (q.UPDATE) return this._set ('path', _path4 (q.UPDATE,'entity'))
       if (q.DELETE) return this._set ('path', _path4 (q.DELETE,'from'))
     }
+    const {_} = this
     if (_.target) return this._set ('path', _.target.name)
     if (_.entity) return this._set ('path', _.entity.name || _.entity)
-    else return this._set ('path', undefined)
+    return this._set ('path', undefined)
   }
 
   set data(d) { if (d) super.data = d }
   get data() {
-    const q = this.query
-    if (!q) return this._set ('data', undefined)
-    const I = q.INSERT
-    if (I) return this._set ('data', I.rows || I.values || I.entries && (I.entries.length > 1 ? I.entries : I.entries[0]) ||{})
-    const U = q.UPDATE
-    if (U) return this._set ('data', U.data ||{})
+    const q = this.query; if (!q) return this._set ('data', undefined)
+    const I = q.INSERT; if (I) return this._set ('data', I.rows || I.values || I.entries && (I.entries.length > 1 ? I.entries : I.entries[0]) ||{})
+    const U = q.UPDATE; if (U) return this._set ('data', U.data ||{})
     return this._set ('data', {})
   }
 
@@ -63,8 +61,9 @@ class Request extends require('./event') {
   warn   (...args) { return this._messages.add (3, ...args) }
   error  (...args) { return this._errors.add (4, ...args) }
   reject (...args) {
-    const e = this.error(...args)
-    throw e.stack ? e : Object.assign(new Error,e)
+    let e = this.error(...args)
+    if (!e.stack) Error.captureStackTrace (e = Object.assign(new Error,e), this.reject)
+    throw e
   }
 
   // Lazily create message collectors for .errors and .messages
@@ -131,10 +130,5 @@ const _path4 = (x,p) => {
 //  REVISIT: Legacy stuff...
 //
 Object.defineProperties (Request.prototype, {
-
-  diff: { value: function (...args) {
-    const {_service:d} = this.target
-    return d ? global.cds.services[d.name]._calculateDiff(this, ...args) : Promise.resolve([])
-  }},
-
+  diff: { get: ()=> require('../../libx/_runtime/cds-services/services/utils/differ').reqDiff }
 })

package/lib/req/response.js

@@ -1,3 +1,5 @@
+const cds = require ('../index')
+
 /**
  * Messages Collector, used for `req.errors` and `req.messages`
  */
@@ -20,9 +22,11 @@ class Responses extends Array {
 }
 
 class Errors extends Responses {
-  throwable() {
-    return this.length === 1 ? this[0] : { message: 'MULTIPLE_ERRORS', details:this }
+  push(e) {
+    'stack' in e || Error.captureStackTrace (e = Object.assign(new Error,e), cds.Request.prototype.error)
+    return super.push(e)
   }
+  throwable() { return this.length > 1 ? Object.assign(new Error('MULTIPLE_ERRORS'), { details: this }) : this[0] }
 }
 
 module.exports = { Responses, Errors }

package/lib/req/user.js

@@ -1,20 +1,21 @@
 class User {
 
   constructor (_) {
-    if (new.target === Anonymous) return; else if (_ === undefined) return new User.default
+    if (_ === undefined) {
+      if (new.target === Privileged) return
+      if (new.target === Anonymous) return
+      else return new User.default
+    }
     if (typeof _ === 'string') { this.id = _; return }
-    for (let each in _) super[each] = _[each] // overrides getters
-    if (Array.isArray(_._roles)) this._roles = _._roles.reduce((p,n)=>{p[n]=1; return p},{})
+    for (let each in _) super[each === '_roles' ? 'roles' : each] = _[each] // overrides getters
+    if (Array.isArray(this.roles)) this.roles = this.roles.reduce ((p,n)=>{p[n]=1; return p},{})
   }
 
   get attr() { return super.attr = {} }
+  get roles(){ return super.roles = {} }
+  get _roles(){ return this.roles } // compatibility
 
-  get _roles(){ return super._roles = {
-    'identified-user': !!this.id,
-    'authenticated-user': !!this.id && this.authLevel !== 'weak' // REVISIT: _.authLevel
-  }}
-
-  is (role) { return role === 'any' || !!this._roles[role] }
+  is (role) { return role === 'any' || role === 'identified-user' || role === 'authenticated-user' && this.authLevel !== 'weak' || !!this.roles[role] }
   valueOf() { return this.id }
 
 }
@@ -22,22 +23,29 @@ class User {
 /**
  * Subclass representing non-identified unauthenticated users.
  */
-class Anonymous extends User {
-  is (role) { return role === 'any' }
-  get _roles() { return {} }
-}
-Anonymous.prototype._is_anonymous = true
-Anonymous.prototype.id = 'anonymous'
+class Anonymous extends User { is(role) { return role === 'any' }}
+Object.defineProperties (Anonymous.prototype, {
+  id: {value:'anonymous',writable:true},
+  roles: {value:{}},
+  attr: {value:{}},
+  _is_anonymous: {value:true},
+})
 
 /**
  * Subclass for executing code with superuser privileges.
  */
-class Privileged extends User {
-  constructor(_) { super(_||{}) }
-  is() { return true }
-}
-Privileged.prototype._is_privileged = true
-Privileged.prototype.id = 'privileged'
+class Privileged extends User { is(){ return true }}
+Object.defineProperties (Privileged.prototype, {
+  id: {value:'privileged',writable:true},
+  roles: {value:{},writable:true},
+  attr: {value:{},writable:true},
+  _is_privileged: {value:true},
+})
+
 
 // exports -----------------
-module.exports = exports = Object.assign (User, { Anonymous, Privileged, default:Anonymous })
+module.exports = exports = Object.assign (User, {
+  Anonymous,  anonymous  : Object.seal (new Anonymous),
+  Privileged, privileged : Object.seal (new Privileged),
+  default: Anonymous,
+})

package/lib/serve/Service-api.js

@@ -1,12 +1,16 @@
 const cds = require('..'), { Event, Request } = cds
 const add_methods_to = require ('./Service-methods')
-const { unfold_csn: cds_localized } = cds.compile._localized
 
 
 class Service extends require('./Service-handlers') {
 
-  constructor (name, model, o={}) {
-    super (name || new.target.name) .options = o
+  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`
+      name = srv.name
+    }
+    super (name || new.target.name) .options = o || (o={})
     if (o.kind) this.kind = o.kind // shortcut
     if (model) this.model = model
   }
@@ -27,7 +31,6 @@ class Service extends require('./Service-handlers') {
    * Messaging API to emit asynchronous event messages, i.e. instances of `cds.Event`.
    */
   emit (event, data, headers) {
-    const res = this._compat_sync (event, data, headers); if (res) return res
     const eve = event instanceof Event ? event : new Event (
       is_object(event) ? event : { event, data, headers }
     )
@@ -43,11 +46,11 @@ class Service extends require('./Service-handlers') {
     )
     return this.dispatch (req)
   }
-  get    (path, data) { return is_rest(path) ? this.send('GET',   path,data) : this.read   (path, data) }
-  put    (path, data) { return is_rest(path) ? this.send('PUT',   path,data) : this.update (path, data) }
-  post   (path, data) { return is_rest(path) ? this.send('POST',  path,data) : this.create (path, data) }
-  patch  (path, data) { return is_rest(path) ? this.send('PATCH', path,data) : this.update (path, data) }
-  delete (path, data) { return is_rest(path) ? this.send('DELETE',path,data) : DELETE.from (path, data).bind(this) }
+  get    (...args) { return is_rest(args[0]) ? this.send('GET',   ...args) : this.read   (...args) }
+  put    (...args) { return is_rest(args[0]) ? this.send('PUT',   ...args) : this.update (...args) }
+  post   (...args) { return is_rest(args[0]) ? this.send('POST',  ...args) : this.create (...args) }
+  patch  (...args) { return is_rest(args[0]) ? this.send('PATCH', ...args) : this.update (...args) }
+  delete (...args) { return is_rest(args[0]) ? this.send('DELETE',...args) : DELETE.from (...args).bind(this) }
 
   /**
    * Querying API to send synchronous requests...
@@ -94,8 +97,11 @@ class Service extends require('./Service-handlers') {
   /**
    * Subclasses may override this to free private resources
    */
-  disconnect (tenant) { // eslint-disable-line no-unused-vars
-    if (this === cds.db) cds.db = undefined //> REVISIT: should go into DatabaseService
+  disconnect (tenant) {
+    if (this === cds.db) {
+      if (tenant && cds.db.dbcs) cds.db.dbcs.delete[tenant]
+      else if (!tenant) cds.db = undefined //> REVISIT: should go into DatabaseService
+    }
     delete cds.services[this.name]
   }
 
@@ -105,7 +111,6 @@ const { dispatch, handle } = require('./Service-dispatch')
 Service.prototype.dispatch = dispatch
 Service.prototype.handle = handle
 Service.prototype.transaction = Service.prototype.tx = require('./Transaction')
-Service.prototype._compat_sync = require('./Service-compat')
 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

@@ -13,22 +13,18 @@ exports.dispatch = async function dispatch (req) { //NOSONAR
 
   // Ensure we are in a proper transaction
   if (!this.context) {
-    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))
-    }
+    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
   }
-  // `this` is a tx from now on...
-  if (!req._tx) req._tx = this
+  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)
 
   // Handle batches of queries
   if (_is_array(req.query))
-    return Promise.all (req.query.map (q => this.dispatch ({query:q,__proto__:req})))
+    return Promise.all (req.query.map (q => this.dispatch ({query:q,__proto__:req,context:req})))
 
   // Ensure target and fqns
   if (!req.target) _ensure_target (this,req)

package/lib/serve/Service-methods.js

@@ -5,7 +5,8 @@ const LOG = cds.log('cds-app-service-methods')
 module.exports = (srv) => {
   if (!( //> we only support that for app services
     srv instanceof cds.ApplicationService ||
-    srv instanceof cds.RemoteService
+    srv instanceof cds.RemoteService ||
+    srv._add_stub_methods
   )) return
   for (const each of srv.operations) {
     add_handler_for (srv, each)
@@ -73,12 +74,12 @@ const add_handler_for = (srv, def) => {
         if (req.data[k]) {
           LOG._warn && LOG.warn(`
           ${target.name} has defined ${k} as key and action parameter.
-          Key will be used in req.data.      
+          Key will be used in req.data.
           `)
         }
         req.data[k] = named ? req.params[0][k] : req.params[pos++]
       }
-      
+
     }
 
     return this.send (req)