@sap/cds 6.0.2 → 6.1.0

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/ql/SELECT.js

@@ -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/req/cds-context.js

@@ -30,7 +30,7 @@ module.exports = new class extends AsyncLocalStorage {
     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
+      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))))

package/lib/req/context.js

@@ -104,6 +104,23 @@ 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() {
+    return super.model = this._propagated.model || this.http?.req.__model // IMPORTANT: Never use that anywhere else
+  }
+  set model(m) {
+    super.model = m
+  }
+
   get timestamp() {
     return super.timestamp = this._propagated.timestamp || new Date
   }
@@ -151,18 +168,29 @@ class EventContext {
     }
   }
   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/index.js → srv/cds-serve.js}

@@ -63,7 +63,7 @@ module.exports = function cds_serve (som, _options) { // NOSONAR
       // skip all services marked to be ignored
       d['@cds.ignore'] || d['@cds.serve.ignore'] ||
       // skip external services, unless asked to mock them and unbound
-      d['@cds.external'] || required[d.name]?.external && (!o.mocked || required[d.name].credentials)
+      (d['@cds.external'] || required[d.name]?.external) && (!o.mocked || required[d.name].credentials)
     ))
     if (services.length > 1 && o.at) {
       throw cds.error `You cannot specify 'path' for multiple services`

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

@@ -1,9 +1,8 @@
-const { pathToFileURL } = require('url')  // on Windows, must use a file: URL for ESM import
 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
@@ -48,7 +47,7 @@ const _require = (it,d) => {
     }
   }
   DEBUG && DEBUG({resolved})
-  return typeof jest !== 'undefined' ? require(resolved) : import(pathToFileURL(resolved).href)
+  return cds.utils._import(resolved)
 }
 
 const _function = (impl) => !_is_class(impl) ? impl : (srv) => {

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={})
@@ -94,6 +94,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 +114,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
@@ -24,7 +24,7 @@ exports.dispatch = async function dispatch (req) { //NOSONAR
 
   // Handle batches of queries
   if (_is_array(req.query))
-    return Promise.all (req.query.map (q => this.dispatch ({query:q,__proto__:req,context:req})))
+    return Promise.all (req.query.map (q => this.dispatch ({query:q,__proto__:req,context:req.context})))
 
   // Ensure target and fqns
   if (!req.target) _ensure_target (this,req)
@@ -107,6 +107,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) => {

package/lib/srv/srv-models.js

@@ -0,0 +1,206 @@
+// REVISIT: all handler caches (incl. templates) need to go into cached models -> eviction
+// REVISIT: all edmx caches also have to be hooked in here
+
+const cds = require ('../index')
+const LOG = cds.log()
+
+const {normalizeError} = require('../../libx/_runtime/common/error/frontend')
+const getError = require('../../libx/_runtime/common/error')
+
+/**
+ * Implements a static cache for all tenant/features-specific models.
+ * Cache keys are strings of the form `<tenant>:<comma-separated-features>`.
+ * The base model `cds.model` is also in the cache with key `':'`, i.e.,
+ * with undefined tenant and no activated features.
+ */
+class ExtendedModels {
+
+  /**
+   * Returns an express middleware to be used with the given srv to set cds.context.model.
+   * Uses `this.model4(...)` to get the respective tenant/features-specific models.
+   * @returns {(req,res)=>{}}
+   */
+  static middleware4 (srv) {
+    if (!(srv instanceof cds.ApplicationService)) return [] //> no middleware to add // REVISIT: move to `srv.isExtensible`
+    if (srv.name?.startsWith('cds.xt.'))          return [] //> no middleware to add // REVISIT: move to `srv.isExtensible`
+    else return async (req,res,next) => {
+      if (!req.user?.tenant) return next()
+      const ctx = cds.context = cds.EventContext.for({ http: { req, res } })
+      ctx.user = req.user // REVISIT: should move to auth middleware?
+      try {
+        ctx.model = req.__model = await this.model4 (ctx.tenant, ctx.features)
+      } catch (e) {
+        LOG.error (Object.assign(e, { message: 'Unable to get service from service map due to error: ' + e.message }))
+
+        // return 503 to client
+        // REVISIT: Error handling!
+        const { error } = normalizeError(getError(Object.assign(e, { statusCode: 503 })), req)
+
+        return res.status(503).json({ error })
+      }
+      next()
+    }
+  }
+
+
+  /**
+   * Returns the model to use for given tenant and features.
+   * Loaded models are cached, with eviction on inactivity of tenants,
+   * and automatically refreshed when new extensions are made.
+   * @returns a CSN compiled.for.nodejs and cds.linked
+   */
+  static async model4 (tenant, features) {
+
+    const {cache} = ExtendedModels, key = cache.key4 (tenant, features)
+    const cached = cache.at(key); if (cached) return cached
+    if (key === ':') return cache.add (':', cds.compile.for.nodejs(cds.model))
+    else return cache[key] = (async()=>{ // temporarily add promise to cache to avoid race conditions...
+
+      // If tenant doesn't have extensions check cache with tenant = undefined
+      const _has_extensions = tenant && extensibility && await _is_extended(tenant)
+      if (!_has_extensions) {
+        let k = cache.key4 (tenant = undefined, features)
+        let cached = cache.at(k); if (cached) return cached
+        else if (k === ':') return cache.add (':', cds.compile.for.nodejs(cds.model))
+      }
+
+      // None cached -> obtain and cache specific model from ModelProvider
+      return await _get_model4 (tenant, Object.keys(features))
+
+    })()
+    .then (m => cache.add(key,m)) // replace promise in cache by real model
+    .catch (e => { delete cache[key]; throw e })
+  }
+
+
+  /**
+   * Constructs and returns a cache key for given tenant and features.
+   * @param {string} tenant string or `undefined` as obtained from `cds.context.tenant`
+   * @param {object} features object as obtained from `cds.context.features`
+   * @returns {string} of the form `<tenant>:<comma-separated-features>`
+   */
+  key4 (tenant, features) {
+    return `${tenant||''}:${features.$hash}`
+  }
+
+
+  /**
+   * Returns the currently cached model, or a promised one.
+   * Promises are added to the cache to avoid race conditions with parallel requests.
+   * This implementation regularly checks for new extensions, and transparently
+   * refreshes cached models if so.
+   * This method is overridden with a simple `return this[key]` when extensibility
+   * is switched off.
+   * @param {string} key as obtained through `cache.key4(t,f)`
+   * @returns { LinkedCSN | Promise<LinkedCSN> }
+   */
+  at (key) {
+    const model = this[key]; if (!model) return
+    if (model.then) return model //> promised model to avoid race conditions
+
+    const {_cached} = model, interval = ExtendedModels.checkInterval
+    if (Date.now() - _cached.touched < interval) return model //> checked recently
+
+    else return this[key] = (async()=>{ // temporarily replace cache entry by promise to avoid race conditions...
+
+      const has_new_extensions = await cds.db.exists('cds.xt.Extensions') .where ({
+        timestamp: { '>': new Date(_cached.touched).toISOString() } // REVISIT: better store epoc time in db?
+        // REVISIT: GAP: CAP runtime should allow Date objects + Date.now() for all date+time types !
+      })
+      if (has_new_extensions) { // new extensions arrived -> refresh model in cache
+        let [ tenant = undefined, toggles ] = key.split(':')
+        return _get_model4 (tenant, toggles.split(','))
+      } else {                        // no new extensions...
+        _cached.touched = Date.now() // check again in 1 min or so
+        return model               // keep cached model in cache
+      }
+
+    })()
+    .then (m => this.add(key,m))  // replace promise in cache by real model
+    .catch (e => { delete this[key]; throw e })
+  }
+
+
+  /**
+   * Adds a model into the cache under the given key.
+   * Only use that method to add loaded models, while using direct assignment
+   * to add promises, e.g. `cache[key] = promised_model`.
+   * @param {string} key as obtained through `cache.key4(t,f)`
+   * @param {LinkedCSN} model the loaded and linked model
+   * @returns the given `model`
+   */
+  add (key, model, touched = Date.now()) {
+    if (model) {
+      if (!model._cached) Object.defineProperty (model,'_cached',{ value:{key,touched} })
+      return this[key] = model
+    }
+  }
+
+
+  /**
+   * When started, regularly evicts models for inactive tenants.
+   */
+  startSentinel(){
+    this.sentinel = setInterval (()=>{ for (let [key,m] of Object.entries(this)) {
+      if (!m._cached) continue // `m` can also be `this.sentinel`
+      if (Date.now() - m._cached.touched > ExtendedModels.sentinelInterval) {
+        delete this [key]
+      }
+    }}, ExtendedModels.sentinelInterval)
+    cds.on('shutdown', ()=> clearInterval(this.sentinel))
+  }
+
+
+  /** The cache instance used by `middleware4()` and `model4()`. */
+  static cache = new ExtendedModels
+
+  /** Time interval in ms to check for new extensions and refresh models, if so. */
+  static checkInterval = cds.requires.extensibility?.tenantCheckInterval || cds.mtx?.tenantCheckInterval || 1 * 60 * 1000
+
+  /** Time interval in ms after which to evict models for inactive tenants. */
+  static sentinelInterval = cds.requires.extensibility?.evictionInterval || 3600*1000
+
+}
+module.exports = ExtendedModels
+
+
+
+// ---------------------------------------------------------------------------
+// Support for old MTX
+
+const old_mtx = cds.mtx
+if (old_mtx) {
+  if (!cds.requires.extensibility) cds.requires.extensibility = true // REVISIT: extensibility was always true in old MTX?
+  ExtendedModels.prototype.at = function (key) { return this[key] }
+  old_mtx.eventEmitter.on (old_mtx.events.TENANT_UPDATED, async (tenant='') => {
+    delete ExtendedModels.cache [tenant+':']
+  })
+}
+
+
+// ---------------------------------------------------------------------------
+// Optimizations for single-tenancy modes
+
+const extensibility = cds.requires.extensibility
+if (!extensibility) {
+  ExtendedModels.prototype.at = function (key) { return this[key] }
+  if (!cds.requires.toggles) ExtendedModels.middleware4 = ()=> []
+}
+
+
+// helper to get model for tenant/features
+const _is_extended = old_mtx ? t => old_mtx.isExtended(t) : extensibility ? ()=> cds.db.exists('cds.xt.Extensions') : ()=> false
+const _get_model4 = old_mtx ? async (tenant) => {
+  const isExtended = tenant && await old_mtx.isExtended(tenant) // REVISIT: avoid await
+  if (isExtended) return old_mtx.getCsn(tenant) .then (cds.compile.for.nodejs)
+} : (tenant, toggles) => {
+  const { 'cds.xt.ModelProviderService':mps } = cds.services
+  return mps.getCsn (tenant, toggles) .then (cds.compile.for.nodejs)
+}
+
+
+// ---------------------------------------------------------------------------
+// Optimizations for single-tenancy modes
+
+if (cds.requires.multitenancy && typeof global.it === 'undefined') ExtendedModels.cache.startSentinel()
+// REVISIT: how to do ^that^ correctly with jest?

package/lib/{serve/Transaction.js → srv/srv-tx.js}

@@ -5,7 +5,7 @@ class RootContext extends EventContext {}
 /**
  * This is the implementation of the `srv.tx(req)` method. It constructs
  * a new Transaction as a derivate of the `srv` (i.e. {__proto__:srv})
- * @returns { Transaction & import('./Service-api') }
+ * @returns { Transaction & import('./srv-api') }
  * @param { EventContext } ctx
  */
 module.exports = function tx (ctx,fn) { const srv = this
@@ -48,6 +48,7 @@ class Transaction {
   static for (srv,root) {
     let txs = root.transactions
     if (!txs) Object.defineProperty(root, 'transactions', {value: txs = new Map})
+    if (srv._real_srv) srv = srv._real_srv // REVISIT: srv._real_srv is a qirty hack for current Okra Adapters
     let tx = txs.get (srv)
     if (!tx) txs.set (srv, tx = new this (srv,root))
     return tx
@@ -58,6 +59,10 @@ class Transaction {
     const proto = new.target.prototype
     tx.commit   = proto.commit.bind(tx)
     tx.rollback = proto.rollback.bind(tx)
+    if (srv.isExtensible) {
+      const m = cds.context?.model
+      if (m) tx.model = m
+    }
     return _init(tx)
   }
 

package/lib/utils/{tests.js → cds-test.js}

@@ -25,7 +25,7 @@ class Test extends require('./axios') {
         this.server = server
         this.url = url
       })
-      try { return cds.exec (cmd, ...args, '--port','0') }
+      try { return cds.exec (cmd, ...args, ...(args.includes('--port') ? [] : ['--port', '0'])) }
       catch (e) { if (is_mocha) console.error(e) } // eslint-disable-line no-console
     })
 
@@ -97,7 +97,7 @@ function support_jest_and_mocha() {
     }
     after(()=>{
       delete global.cds
-      for (let k in require.cache) delete require.cache[k]
+      for (let k in require.cache) delete require.cache[k] // REVISIT: Whay are we doing that?
     })
   } else if (is_jest) { // it's jest
     global.before = (msg,fn) => global.beforeAll(fn||msg)