@sap/cds 5.9.8 → 6.0.1

package/lib/serve/Transaction.js

@@ -2,7 +2,6 @@ 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
  * a new Transaction as a derivate of the `srv` (i.e. {__proto__:srv})
@@ -16,23 +15,27 @@ module.exports = function tx (ctx,fn) { const srv = this
   // Last arg may be a function -> srv.tx (tx => { ... })
   if (typeof ctx === 'function') [ ctx, fn ] = [ undefined, ctx ]
   if (typeof fn === 'function') {
-    const tx = srv.tx(ctx)
-    return Promise.resolve(tx).then(fn) .then (tx.commit,tx.rollback)
+    const tx = srv.tx(ctx), fx = ()=> Promise.resolve(fn(tx)).then(tx.commit,tx.rollback)
+    const gc = cds.context, _has_tx = gc && gc.tx && !gc.tx._done
+    return _has_tx ? fx() : cds._context.run(tx,fx)
   }
 
-  // This is for compatibility with cds.tx(req)
-  if (ctx instanceof EventContext) {
-    if (ctx.context !== ctx) return NestedTransaction.for (srv, ctx.context)
-    if (ctx._tx) return NestedTransaction.for (srv, ctx)
-    else return RootTransaction.for (srv, ctx)
-  }
+  if (ctx) {
+    if (ctx.context) ctx = ctx.context
 
-  // `ctx` is a plain context object or undefined
-  if (ctx) { // REVISIT: This is for compatibility with AFC only
+    // REVISIT: This is for compatibility with former srv.tx(req) usages
+    if (ctx instanceof EventContext) {
+      if (ctx.tx) return NestedTransaction.for (srv, ctx)
+      else return RootTransaction.for (srv, 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: RootContext.for(ctx) }) // > must be non-enumerable
-    return RootTransaction.for (srv, ctx._txed_before)
+    else Object.defineProperty(ctx, '_txed_before', { value: ctx = RootContext.for(ctx) })
+    return RootTransaction.for (srv, ctx)
   }
+
+  // `ctx` is a plain context object or undefined
   return RootTransaction.for (srv, RootContext.for(ctx))
 }
 
@@ -51,11 +54,11 @@ class Transaction {
   }
 
   constructor (srv,root) {
-    const tx = _init ({ __proto__:srv, context:root })
+    const tx = { __proto__:srv, context:root }
     const proto = new.target.prototype
     tx.commit   = proto.commit.bind(tx)
     tx.rollback = proto.rollback.bind(tx)
-    return tx
+    return _init(tx)
   }
 
   /**
@@ -103,7 +106,7 @@ class RootTransaction extends Transaction {
    * @param {EventContext} root
    */
   static for (srv,root) {
-    return root._tx = super.for (srv,root)
+    return root.tx = super.for (srv,root)
   }
 
   /**
@@ -111,7 +114,7 @@ class RootTransaction extends Transaction {
    * are informed by emitting 'succeeded' event to them all.
    */
   async commit (res) {
-    if (cds_tx_protection) this.context._done = 'committed'
+    if (cds_tx_protection) this._done = 'committed'
     try {
       await this.context.emit ('commit',res) //> allow custom handlers req.before('commit')
       await super.commit (res)
@@ -131,7 +134,7 @@ class RootTransaction extends Transaction {
     // nothing to do if transaction already rolled back (we need to check here as well to not emit failed twice)
     if (this.ready === 'rolled back') return
 
-    if (cds_tx_protection) this.context._done = 'rolled back'
+    if (cds_tx_protection) this._done = 'rolled back'
     try {
       await this.context.emit ('failed',err)
       await super.rollback (err)
@@ -172,11 +175,11 @@ const _init = (tx) => {
 const _begin = async function (req) {
   if (!req.query && req.method === 'BEGIN') // IMPORTANT: !req.query is to exclude batch requests
     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) {
+  // Protection against unintended tx.run() after root tx.commit/rollback()
+  if (typeof this.ready === 'string' || !this.ready && this.context.tx._done) {
     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`,
+      `Transaction is ${this.ready || this.context.tx._done}, no subsequent .run allowed, without prior .begin`,
       { code: 'TRANSACTION_CLOSED' }
     )
   }

package/lib/serve/adapters.js

@@ -1,18 +1,18 @@
 const lib = require('../../libx/_runtime')
+const cds = require('../index')
 const registry = {
-  get rest() { return lib.to.old_rest },
-  get new_rest() { return lib.to.new_rest },
+  get rest() { return lib.to.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 },
+  none: ()=>{}
 }
 
 
 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`)
   }
@@ -33,10 +33,20 @@ 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
-    lib.perf (app)
-    lib.auth (srv, app, srv.options)
     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)
     return srv
   }

package/lib/serve/factory.js

@@ -1,3 +1,4 @@
+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 })
@@ -5,9 +6,10 @@ const DEBUG = cds.debug('srv.factory'); DEBUG && DEBUG ({ 'cds.root':cds.root, p
 /** @typedef {import('./Service-api')} Service @type { (()=>Service) & (new()=>Service) } */
 const ServiceFactory = function (name, model, options) { //NOSONAR
 
-  const o = {...options} // avoid changing shared options
-  const serve = !cds.requires[name] || o.mocked
-  const defs = !model ? {[name]:{}} : model.definitions || cds.error (`Invalid argument for 'model': ${model}`)
+  const o = { ...options } // avoid changing shared options
+  const conf = cds.requires[name]
+  const serve = !(conf && conf.external && (!o.mocked || conf.credentials))
+  const defs = !model ? {[name]:{}} : model.definitions || cds.error `Invalid argument for 'model': ${model}`
   const def = !name || name === 'db' ? {} : defs[name] || {}
   DEBUG && DEBUG ({ name, definition:def, options:o })
 
@@ -18,21 +20,21 @@ const ServiceFactory = function (name, model, options) { //NOSONAR
   if (it = o.impl)                 return _use (it) // from cds.connect (<options>)
   return _use (_required())
 
-  function _use (it) {
+  async function _use (it) {
     if (it._is_service_class)     return new it (name,model,o)
     if (it._is_service_instance)  return it
-    if (typeof it === 'function') return _use (_required(), /*with:*/ o.impl = _function(it)) // NOSONAR
-    if (typeof it === 'object')   return _use (it && it[name] || _required())
-    if (typeof it === 'string')   return Object.assign (_use (_require(it,def)), {_source:it})
-    throw cds.error (`Invalid service implementation for ${name}: ${it}`)
+    if (typeof it === 'function') return _use (await _required(), /*with:*/ o.impl = _function(it)) // NOSONAR
+    if (typeof it === 'object')   return _use (it[name] || it.default || await _required())
+    if (typeof it === 'string')   return Object.assign (await _use (await _require(it,def)), {_source:it})
+    throw cds.error `Invalid service implementation for ${name}: ${it}`
   }
 
   function _required() {
     const kind = o.kind = serve && def['@kind'] || o.kind || 'app-service'
     if (_require[kind]) return _require[kind]
-    const {impl} = cds.requires[kind] || cds.error (`No configuration found for 'cds.requires.${kind}'`)
+    const {impl} = cds.requires[kind] || cds.requires.kinds[kind] || cds.error `No configuration found for 'cds.requires.${kind}'`
     DEBUG && DEBUG ('requires',{kind,impl})
-    return _require[kind] = _require (impl || cds.error (`No 'impl' configured for 'cds.requires.${kind}'`))
+    return _require[kind] = _require (impl || cds.error `No 'impl' configured for 'cds.requires.${kind}'`)
   }
 }
 
@@ -41,13 +43,12 @@ const _require = (it,d) => {
   if (it.startsWith('@sap/cds/')) it = cds.home + it.slice(8)  //> for local tests in @sap/cds dev
   if (it.startsWith('./')) it = _relative (d,it.slice(2))     //> relative to <service>.cds
   try { var resolved = require.resolve(it,{paths}) } catch(e) {
-    try { resolved = require.resolve(it = path.resolve(cds.root,it)) } catch(e) { // for compatibility
-      DEBUG && DEBUG (`Failed loading service implementation from '${it}'`, { 'cds.root':cds.root, paths })
-      throw cds.error(`Failed loading service implementation from '${it}'`)
+    try { resolved = require.resolve(path.join(cds.root,it)) } catch(e) { // compatibility
+      throw cds.error `Failed loading service implementation from '${it}' ${{ Reason:e, paths, 'cds.root':cds.root }}`
     }
   }
   DEBUG && DEBUG({resolved})
-  return require(resolved)
+  return typeof jest !== 'undefined' ? require(resolved) : import(pathToFileURL(resolved).href)
 }
 
 const _function = (impl) => !_is_class(impl) ? impl : (srv) => {
@@ -58,12 +59,9 @@ const _function = (impl) => !_is_class(impl) ? impl : (srv) => {
 }
 
 const sibling = (d) => {
-  const src = _source(d), home = path.resolve(cds.root,src,'..')
-  const file = path.parse(src).name
-  for (let each of ['', './lib', './handlers']) {
-    let found
-    if (process.env.CDS_TYPESCRIPT === 'true') found = isfile(path.join(home, each, file + '.ts'))
-    if (!found) found = isfile(path.join(home, each, file + '.js'))
+  const { dir, name } = path.parse(_source(d)), TS = process.env.CDS_TYPESCRIPT
+  for (let subdir of ['', './lib', './handlers']) {
+    let found = TS && _resolve(dir,subdir,name+'.ts') || _resolve(dir,subdir,name+'.js')
     if (found)  return found //> equiv to '.'+found.slice(home.length)
   }
 }
@@ -71,6 +69,11 @@ const sibling = (d) => {
 // Note: @source has precedence over $location for csn.json cases
 const _source = (d) => d['@source'] || (d['@source'] = d.$location && d.$location.file.replace(/\\/g, '/') || '.')
 const _relative = (d,x,cwd=cds.root) => typeof x !== 'string' ? x : path.resolve (cwd, _source(d),'..',x)
+const _resolve = (...args) => {
+  const f = path.join(...args)
+  try { return require.resolve(f) }
+  catch(e) { if (e.code === 'MODULE_NOT_FOUND') return isfile(path.resolve(cds.root,f)); else throw e }
+}
 const _is_class = (impl) => typeof impl === 'function' && impl.prototype && /^class\b/.test(impl)
 
 module.exports = Object.assign (ServiceFactory, { Service: ServiceFactory, resolve:_relative })

package/lib/serve/index.js

@@ -4,9 +4,9 @@ const { Service } = cds.service.factory
 const _ready = Symbol(), _pending = cds.services._pending || {}
 
 /** @param som - a service name or a model (name or csn) */
-function cds_serve (som, _options) { // NOSONAR
+module.exports = function cds_serve (som, _options) { // NOSONAR
 
-  if (som && typeof som === 'object' && !is_csn(som)) {
+  if (som && typeof som === 'object' && !is_csn(som) && !is_files(som)) {
     [som,_options] = [undefined,
       som._is_service_instance ? { service:som, from:'*' } :
       som._is_service_class    ? { service:som, from:'*' } :
@@ -16,35 +16,27 @@ function cds_serve (som, _options) { // NOSONAR
   else if (Array.isArray(som) && som.length === 1) som = som[0]
   const o = {..._options} // we must not modify inbound data
 
-  // 1) Use fluent API to fill in remaining options...
-  const fluent = {
-    from (model)  { o.from = model;    return this },
-    with (impl)   { o.with = impl;     return this },
-    at (path)     { o.at   = path;     return this },
-    to (protocol) { o.to   = protocol; return this },
-  }
-
-  // 2) Ensure options are filled in canonically based on defaults
+  // Ensure options are filled in canonically based on defaults
   const options = Promise.resolve(o).then (o => { // noformat
     if (o.service)     { o.from     ||( o.from    = som); return o }
     if (o.from)        { o.service  ||( o.service = som); return o }
     if (som === 'all') { o.service ='all'; o.from = '*' ; return o }
     if (is_csn(som))   { o.service ='all'; o.from = som ; return o }
-    if (is_file(som))  { o.service ='all'; o.from = som ; return o }
+    if (is_files(som)) { o.service ='all'; o.from = som ; return o }
     if (is_class(som)) { o.service = som;  o.from = '?' ; return o }
     else               { o.service = som;  o.from = '*' ; return o }
   })
 
-  // 3) Load/resolve the model asynchronously...
+  // Load/resolve the model asynchronously...
   const loaded = options.then (async ({from}=o) => {
     if (!from || from === 'all' || from === '*') from = cds.model || '*'
     if (from.definitions) return from
     if (from === '?') try { return await cds.load('*',o) } catch(e){ return }
-    return cds.load(from,o)
+    return cds.load(from, {...o, silent:true })
   })
 
-  // 4) Pass 1: Construct service provider instances...
-  const all=[], provided = loaded.then (csn => { // NOSONAR
+  // Pass 1: Construct service provider instances...
+  const all=[], provided = loaded.then (async csn => { // NOSONAR
 
     // Shortcut for directly passed service instances
     if (o.service && o.service._is_service_instance) {
@@ -54,7 +46,7 @@ function cds_serve (som, _options) { // NOSONAR
     // Shortcut for directly passed service classes
     if (o.service && o.service._is_service_class) {
       const Service = o.service, d = { name: o.service.name }
-      const srv = _new (Service, d,csn,o)
+      const srv = await _new (Service, d,csn,o)
       return all.push (srv)
     }
 
@@ -71,17 +63,17 @@ 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
-      required[d.name] && (!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`
     }
 
     // Construct service instances and register them to cds.services
-    all.push (...services.map (d => _new (Service,d,csn,o)))
+    all.push (... await Promise.all (services.map (d => _new (Service,d,csn,o))))
   })
 
-  // 5) Pass 2: Finalize service bootstrapping by calling their impl functions.
+  // Pass 2: Finalize service bootstrapping by calling their impl functions.
   // Note: doing that in a second pass guarantees all own services are in
   // cds.services, so they'll be found when they cds.connect to each others.
   let ready = provided.then (()=> Promise.all (all.map (async srv => {
@@ -95,61 +87,66 @@ function cds_serve (som, _options) { // NOSONAR
   })))
 
 
-  // 6) Fluent method to serve constructed providers to express app
-  fluent.in = (app) => {
-    ready = ready.then (()=>{
-      const edms = {}
-      if (cds.env.features.precompile_edms) { // > unofficial config for eval
-        const all = cds.compile.to.edm(cds.model, { service: 'all' })
-        for (let [edm,{ file }] of all) edms[file] = edm
-      }
+  // Return fluent API to fill in remaining options...
+  return {
 
-      for (let each of all) {
-        each._edm = edms[each.name]
+    from (model)  { o.from = model;    return this },
+    with (impl)   { o.with = impl;     return this },
+    at (path)     { o.at   = path;     return this },
+    to (protocol) { o.to   = protocol; return this },
+
+    /** Fluent method to serve constructed providers to express app */
+    in (app) {
+      ready = ready.then (()=> all.forEach (each => {
+        const d = each.definition
+        if (d['@protocol'] === 'none' || d['@cds.api.ignore']) return each._is_dark = true
         ProtocolAdapter.serve(each,o.to).in(app)
         if (!o.silent) cds.emit ('serving',each)
+      }))
+      return this
+    },
+
+    /** Finally resolve to a single picked provider or a map of all */
+    then: (resolve, failed) => ready.then (()=>{
+      if (all.length === 0) return resolve()
+      let response={}
+      for (let each of all) {
+        response[each.name] = each._is_dark || !each.definition ? each : ProtocolAdapter.serve(each,o.to).asRouter()
       }
-    })
-    return fluent
-  }
-
-  // 7) Finally resolve to a single picked provider or a map of all
-  fluent.then = (resolve, failed) => ready.then (()=>{
-    if (all.length === 0) return resolve()
-    let response={}
-    for (let each of all) {
-      response[each.name] = !each.definition ? each : ProtocolAdapter.serve(each,o.to).asRouter()
-    }
-    if (all.length === 1 && all[0].name.endsWith (o.service)) {
-      response = Object.assign (all[0], response)
-    }
-    return resolve (response)
-  }, failed)
-  fluent.catch = (e) => ready.catch(e)
+      if (all.length === 1) {
+        response = Object.assign (all[0], response)
+      }
+      return resolve (response)
+    }, failed),
 
-  return fluent
+    catch: (e) => ready.catch(e)
+  }
 }
 
 
-function _new (Service, d,m,o) {
-  const srv = new Service (d.name,m,o)
+async function _new (Service, d,m,o) {
+  const srv = await new Service (d.name,m,o)
   const required = cds.requires[d.name]
   if (required) {
+    // Object.assign (srv.options, required)
     if (required.name) srv.name = required.name
-    if (o.mocked) srv.mocked = true
+    if (required.external && o.mocked) srv.mocked = true
   }
   if (!srv.path) srv.path = cds.service.path4(srv,o.at)
   _pending[srv.name] = new Promise (r => srv[_ready]=r).finally(()=>{
     delete _pending[srv.name]
     delete srv[_ready]
+    if (srv.mocked) {
+      let service = cds.env.requires[srv.name]?.service
+      if (service && !cds.services[service]) Object.defineProperty (cds.services, service, {value:srv})
+    }
   })
   return srv
 }
 
 
 const is_csn = x => x && x.definitions
-const is_file = x => typeof x === 'string' && !/^[\w$]*$/.test(x)
+const is_files = x => Array.isArray(x) || typeof x === 'string' && !/^[\w$]*$/.test(x)
 const is_class = x => typeof x === 'function' && x.prototype && /^class\b/.test(x)
 
-Object.defineProperty (cds_serve, 'path4', { get(){ return cds.service.path4 } })
-module.exports = cds_serve
+Object.defineProperty (module.exports, 'path4', { get(){ return cds.service.path4 } })

package/lib/utils/axios.js

@@ -36,18 +36,14 @@ const _args = (args) => {
 }
 
 const _error = (e) => {
-  if (e.code === 'ECONNREFUSED' && e.port === 80 /*unchanged default port*/) {
-    // retain original error properties (code,...)
-    e = Object.assign(new Error(e.message +
-      '\nIt seems that the server was not started. Make sure to call \'cds.test(...)\' or \'cds.test.run(...)\'.'),e)
-    e.stack = null // stack is just clutter here
-    throw e
-  }
-  if (!e.response)  throw e
-  if (!e.response.data)  throw e
-  if (!e.response.data.error)  throw new Error(e.message + '\n\n' + JSON.stringify(e.response.data, null, 2))
-  const { code, message } = e.response.data.error
-  throw new Error (code && code !== 'null' ? `${code} - ${message}` : message)
+  Error.captureStackTrace (e,_error) //> adds the stack trace from caller code
+  if (e.code === 'ECONNREFUSED' && e.port === 80 /* default port */) throw Object.assign (e, {
+    message:  e.message + '\nIt seems that the server was not started. Make sure to call \'cds.test(...)\' or \'cds.test.run(...)\'.',
+    stack: null // stack is just clutter here
+  })
+  const { code, message } = e.response && e.response.data && e.response.data.error || {}
+  if (message) e.message = code && code !== 'null' ? `${code} - ${message}` : message
+  throw e
 }
 
 const _ = Axios.prototype // eslint-disable-line no-unused-vars

package/lib/utils/index.js

@@ -1,7 +1,7 @@
 const cwd = process.env._original_cwd || process.cwd()
 const path = require ('path'), { dirname, join, resolve, sep, relative } = path
 const fs = require('fs')
-const cds = global.cds
+const cds = require('../index')
 
 const all = module.exports = exports = { ...fs,
   get inspect() { return $set (this, 'inspect', require('util').inspect) },
@@ -11,7 +11,7 @@ const all = module.exports = exports = { ...fs,
 exports.fs = all
 exports.path = path
 
-exports.local = (file) => '.' + sep + relative(cwd,file)
+exports.local = (file) => relative(cwd,file)
 
 exports.readdir = async function (x) {
   const d = resolve (cds.root,x)
@@ -92,7 +92,7 @@ exports.copy = async function copy (x,y) {
     const entries = await fs.promises.readdir(src)
     return Promise.all (entries.map (async each => {
       const e = join (src,each)
-      const f = join (src,each)
+      const f = join (dst,each)
       return copy (e,f)
     }))
   } else {

package/lib/utils/resources/index.js

@@ -6,48 +6,8 @@ const { packArchive, packArchiveCLI, unpackArchive, unpackArchiveCLI } = require
 const { exists } = require('./utils')
 
 // use tar command line interface
-const TAR_CLI = true
 const TEMP_DIR = fs.realpathSync(require('os').tmpdir())
 
-const findCsvFiles = async (folder, deep = false) => {
-  const files = await fs.promises.readdir(folder)
-  const result = []
-
-  for (const file of files) {
-    const filePath = path.join(folder, file)
-    if (deep && (await fs.promises.stat(filePath)).isDirectory()) {
-      const files = await findCsvFiles(filePath)
-      result.push(...files)
-    } else {
-      if (path.extname(file) === '.csv') {
-        result.push(filePath)
-      }
-    }
-  }
-
-  return result
-}
-
-const collectCsvFiles = async sources => {
-  const folders = sources.map(file => path.dirname(file))
-  const uniqueFolders = [...new Set(folders)].filter(folder => !/node_modules/.test(folder))
-  const db = (cds.env.folders && cds.env.folders.db) || 'db/'
-  let dbFolder = path.join(global.cds.root, db)
-  if (dbFolder.endsWith('/') || dbFolder.endsWith('\\')) dbFolder = dbFolder.slice(0, -1)
-  if (!uniqueFolders.includes(dbFolder)) uniqueFolders.push(dbFolder)
-
-  const result = []
-  for (const folder of uniqueFolders) {
-    const dataPath = path.join(folder, 'data')
-    const dataFiles = (await exists(dataPath)) ? await findCsvFiles(dataPath) : []
-    const csvPath = path.join(folder, 'csv')
-    const csvFiles = (await exists(csvPath)) ? await findCsvFiles(csvPath) : []
-    result.push(...dataFiles, ...csvFiles)
-  }
-
-  return result
-}
-
 const packTarArchive = async (files, root, flat = false, cli = true) => {
   let tgzBuffer, temp
 
@@ -83,7 +43,7 @@ const packTarArchive = async (files, root, flat = false, cli = true) => {
 const unpackTarArchive = async (buffer, folder, cli = true) => {
   const temp = await fs.promises.mkdtemp(`${TEMP_DIR}${path.sep}tar-`)
   const tgz = path.join(temp, 'resources.tgz')
-  await fs.promises.writeFile(tgz, buffer, 'binary')
+  await fs.promises.writeFile(tgz, Buffer.from(buffer), 'binary')
 
   try {
     cli ? await unpackArchiveCLI(tgz, folder) : await unpackArchive(tgz, folder)
@@ -93,9 +53,6 @@ const unpackTarArchive = async (buffer, folder, cli = true) => {
 }
 
 module.exports = {
-  TAR_CLI,
-  findCsvFiles,
-  collectCsvFiles,
   packTarArchive,
   unpackTarArchive
 }

package/lib/utils/resources/tar.js

@@ -1,9 +1,9 @@
 const fs = require('fs')
 const path = require('path')
-const tar = require('tar')
 const exec = require('child_process').exec
 
 const _createArchive = (files, root) => {
+  const tar = require('tar')
   return tar.c(
     {
       gzip: true,
@@ -45,6 +45,7 @@ const packArchiveCLI = async (files, root, output) => {
 }
 
 const unpackArchive = async (tgz, folder) => {
+  const tar = require('tar')
   await tar.x({
     file: tgz,
     gzip: true,

package/lib/utils/tests.js

@@ -8,26 +8,23 @@ class Test extends require('./axios') {
    */
   run (cmd='.', ...args) {
 
-    this.cmd = cmd, this.args = args
+    const {cds} = this; this.cmd = cmd, this.args = args
+    if (!/^(serve|run)$/.test(cmd)) try {
+      const project = cds.utils.isdir(cmd) || require.resolve (cmd+'/package.json').slice(0,-13)
+      this.cmd = cmd = 'serve'; args.push ('--in-memory?')
+      this.in (project)
+    } catch(e) {
+      throw cds.error (`No such folder or package '${process.cwd()}' -> '${cmd}'`)
+    }
 
     // launch cds server...
-    before (`launching ${cmd} ${args.join(' ')}...`, () => { // NOSONAR
-
-      const {cds} = this
-      if (!/^(serve|run)$/.test(cmd)) try {
-        const project = cds.utils.isdir (cmd) || require.resolve (cmd+'/package.json').slice(0,-13)
-        cmd='serve'; args.push ('--in-memory?', '--project', project)
-      } catch(e) {
-        throw cds.error (`No such folder or package '${process.cwd()}' -> '${cmd}'`)
-      }
-
+    before (`launching ${cmd} ${args.join(' ')}...`, () => {
       cds.once ('listening', ({server,url}) => {
         const axp = Reflect.getOwnPropertyDescriptor(this,'axios')
         if (axp) axp.value.defaults.baseURL = url
         this.server = server
         this.url = url
       })
-
       try { return cds.exec (cmd, ...args, '--port','0') }
       catch (e) { if (is_mocha) console.error(e) } // eslint-disable-line no-console
     })
@@ -51,7 +48,7 @@ class Test extends require('./axios') {
    */
   in (...paths) {
     const {cds} = this; cds.root = require('path').resolve (cds.root, ...paths)
-    // const env = Reflect.getOwnPropertyDescriptor(global.cds,'env')
+    // const env = Reflect.getOwnPropertyDescriptor(cds,'env')
     // if (env && env.value && env.value._home !== cds.root) {
     //   throw new Error (`[cds.test] - 'cds.env' was invoked before 'cds.test.in' from a different home:
 
@@ -136,10 +133,11 @@ function initLogging() {
     ? { deploy:'info', serve:'info', server:'info',cds:'info' }
     : { deploy:'warn', serve:'warn', server:'warn',cds:'silent' /* silences provoked request errors */ }
 
-  const env = Reflect.getOwnPropertyDescriptor(global.cds,'env')
+  const cds = require('../index')
+  const env = Reflect.getOwnPropertyDescriptor(cds,'env')
   for (const id of Object.keys(levels)) {
     if (env && env.value)
-      global.cds.log(id, { level:levels[id] })
+      cds.log(id, { level:levels[id] })
     else // uninitialized cds.env -> set env variables to avoid initializing cds.env eagerly
       process.env['cds_log_levels_'+id] = levels[id]
   }

package/libx/_runtime/.eslintrc

@@ -3,7 +3,7 @@
     "node": true,
     "jest": true
   },
-  "extends": ["prettier-standard"],
+  // "extends": ["prettier-standard"],
   "ignorePatterns": ["**/okra/**/*.js"],
   "rules": {
     "no-console": ["error"],