@sap/cds 6.8.4 → 7.0.0

package/lib/srv/protocols/index.js

@@ -7,11 +7,7 @@ class ProtocolAdapter {
    * Provides canonicalized protocols configurations
    */
   static init (protocols = { ...cds.env.protocols }) {
-    for (let [k,o] of Object.entries(protocols)) if (typeof o === 'string') protocols[k] = {path:o}
-    if (!protocols.odata) protocols.odata = { impl: join(__dirname,'odata-v4') }
-    if (!protocols.rest) protocols.rest = { impl: join(__dirname,'rest') }
-    // odata must always be first for fallback
-    return this.protocols = { odata: protocols.odata, ...protocols }
+    return this.protocols = protocols
   }
 
   /**
@@ -29,64 +25,82 @@ class ProtocolAdapter {
   /**
    * Constructs a new adapter for the given service, or returns a formerly constructed one
    */
-  static for (srv, p = srv.options?.to || protocol4(srv.definition)) {
+  static for (srv, p = srv.options?.to || protocol4(srv.definition)) { // TODO default for param p? 
     const cache = srv._adapters || (srv._adapters={}); if (p in cache) return cache[p]
     const impl = this.middlewareFor(p), conf = this.protocols[p]
     return cache[p] = impl (srv, conf)
   }
 
   /**
-   * Constructs a new adapter for the given service, and mounts it to an express app.
+   * Returns the defined protocols for the given service
    */
-  static serve (srv, /* in: */ app, { before, after } = cds.middlewares) {
-    const adapter = this.for(srv); if (!adapter) return
-    app.use (srv.path+'/webapp/', (_,res) => res.sendStatus(404))
-    app.use (srv.path, before, adapter, after)
-    return adapter
+  static protocols4 (def) {
+    // String, provided via srv.options.to
+    if(typeof def === 'string') {
+      return [{ kind: def }]
+    }
+  
+    // @protocol
+    let atProtocol = def?.['@protocol']
+    if (atProtocol) {
+      if (!Array.isArray(atProtocol)) atProtocol = [atProtocol]
+      return atProtocol.map(p => typeof p === 'string' ? { kind: p } : p)
+    }
+  
+    // @odata, @rest, ...
+    const atProtocolDirect = Object.keys(this.protocols).find(p => def?.['@'+p])
+    if (atProtocolDirect) return [{ kind: atProtocolDirect }]
+  
+    // No protocol annotation found -> serve odata
+    return [{ kind: Object.keys(this.protocols)[0] || 'odata-v4' }]
   }
 
   /**
-   * Serve protocols at configured paths, if any; e.g. /hcql/browse, /graphql/...
+   * Constructs a new adapter for the given service, and mounts it to an express app.
    */
-  static serveAll (protocols = Object.entries(ProtocolAdapter.protocols).filter(([,o]) => o.path)) {
-    if (protocols?.length) cds.once ('served', ()=>{
-      const LOG = cds.log(), DEBUG = cds.debug('adapters')
-      for (let [ protocol, options ] of protocols) {
-        let globalAdapter = false
-        for (let srv of cds.service.providers) {
-          if (!protocol4(srv.definition,null)) {
-            let adapter = ProtocolAdapter.middlewareFor(protocol); if (!adapter) continue
-            if (is_global(adapter)) { globalAdapter = adapter; break }
-            _serve (adapter(srv,options), options.path + srv.path, protocol, options)
-          }
-        }
-        if (globalAdapter) {
-          options = { ...options, services: cds.service.providers
-            .filter (srv => { let p = protocol4(srv.definition,null); return !p || p === protocol })
-            .reduce ((all,srv) => (all[srv.path.slice(1)] = srv, all), {})
-          }
-          _serve (globalAdapter(options), options.path, protocol, options)
+  static serve (srv, /* in: */ app, { before, after } = cds.middlewares) {
+    const DEBUG = cds.debug('adapters')
+    const protocols = this.protocols4(srv.options?.to || srv.definition)
+
+    if (protocols.length > 1 && !cds.requires.middlewares) {
+      cds.error `Cannot serve multiple protocols if cds.requires.middlewares is set to false`
+    }
+
+    const srvDefPath = srv.definition?.['@path']
+    if (protocols.length > 1 && srvDefPath?.[0] === '/') {
+      cds.error `Cannot serve entity with absolute @path (starting with '/') for more than one protocol`
+    }
+
+    let adapter, path, prefix
+    for (let p of protocols) {
+      adapter = this.for(srv, p.kind); if (!adapter) continue
+      path = srv.options?.at || srv.options?.path || p.path || srvDefPath || cds.service.path4(srv).slice(1)
+
+      if (path[0] !== '/') {
+        if (protocols.length === 1 && cds.env.features.serve_on_root) {
+          app.use (`/${path}/webapp/`, (_,res) => res.sendStatus(404))
+          DEBUG?.('app.use(', path, ', ... )')
+          app.use (`/${path}`, before, adapter, after)
         }
+
+        prefix = this.protocols[p.kind].path
+        prefix = prefix ? (prefix.endsWith('/') ? prefix : prefix + '/') : '/'
+        path = prefix + path
       }
-      function _serve (adapter, path, protocol, options) {
-        if (!_serve.first) { _serve.first = true; console.log() }
-        if (!_serve[protocol]) LOG.info ('serving', _serve[protocol] = { protocol, at: options.path })
-        DEBUG?.('app.use(', path, ', ... )')
-        cds.app.use (path, cds.middlewares.before, adapter, cds.middlewares.after)
-      }
-    })
+
+      DEBUG?.('app.use(', path, ', ... )')
+      app.use (path, before, adapter, after)
+      // REVISIT this doesn't handle multiple protocols correctly
+      srv.path = path
+    }
   }
 }
 
-
 const protocols = Object.keys(ProtocolAdapter.init())
-const protocol4 = (def, _default = protocols[0]) => def?.['@protocol'] || protocols.find(p => def['@'+p]) || _default
-const is_global = adapter => adapter.length === 1 && !/^(function )?(\w+\s+)?\((srv|service)/.test(adapter)
+// REVISIT remove protocol4 (and protocols variable)
+const protocol4 = (def, _default = protocols[0] || 'odata-v4') => def?.['@protocol'] || protocols.find(p => def['@'+p]) || _default
 
 module.exports = { ProtocolAdapter, protocol4 }
-if (cds.env.protocols) {
-  cds.middlewares = require('../middlewares')
-  ProtocolAdapter.serveAll()
-} else if (!cds.requires.middlewares) {
+if (!cds.env.protocols && !cds.requires.middlewares) {
   module.exports.ProtocolAdapter = require('./_legacy')
 }

package/lib/srv/protocols/odata-v2-proxy.js

@@ -125,8 +125,6 @@ function convertToNodeHeaders(webHeaders) {
  * @param {string} options.target Target which points to OData V4 backend host:port. Use 'auto' to infer the target from server url after listening. Default is e.g. 'http://localhost:4004'.
  * @param {string} options.targetPath Target path to which is redirected. Default is ''.
  * @param {object} options.services Service mapping object from url path name to service name. Default is {}.
- * @param {boolean} options.mtxRemote CDS model is retrieved remotely via MTX endpoint for multitenant scenario (old MTX only). Default is false.
- * @param {string} options.mtxEndpoint Endpoint to retrieve MTX metadata when option 'mtxRemote' is active (old MTX only). Default is '/mtx/v1'.
  * @param {boolean} options.ieee754Compatible Edm.Decimal and Edm.Int64 are serialized IEEE754 compatible. Default is true.
  * @param {number} options.fileUploadSizeLimit File upload file size limit (in bytes). Default is 10485760 (10 MB).
  * @param {boolean} options.continueOnError Indicates to OData V4 backend to continue on error. Default is false.
@@ -172,8 +170,6 @@ function cov2ap(options = {}) {
   let target = optionWithFallback("target", `http://${DefaultHost}:${port}`);
   const logLevel = optionWithFallback("logLevel", 'info');
   const services = optionWithFallback("services", {});
-  const mtxRemote = optionWithFallback("mtxRemote", false);
-  const mtxEndpoint = optionWithFallback("mtxEndpoint", "/mtx/v1");
   const ieee754Compatible = optionWithFallback("ieee754Compatible", true);
   const fileUploadSizeLimit = optionWithFallback("fileUploadSizeLimit", 10 * 1024 * 1024);
   const continueOnError = optionWithFallback("continueOnError", false);
@@ -228,11 +224,6 @@ function cov2ap(options = {}) {
     service.$linkProviders.push(provider);
   });
 
-  if (cds.mtx && cds.mtx.eventEmitter && cds.env.requires && cds.env.requires.multitenancy) {
-    cds.mtx.eventEmitter.on(cds.mtx.events.TENANT_UPDATED, (tenant) => {
-      delete proxyCache[tenant];
-    });
-  }
   // TODO: Cache invalidation for Streamlined MTX (when extensibility is supported)
 
   router.use(`${path}/:service`, async (req, res, next) => {
@@ -604,14 +595,8 @@ function cov2ap(options = {}) {
 
   async function getMetadata(req, service) {
     let metadata;
-    if (req.tenant) {
-      if (mtxRemote && mtxEndpoint) {
-        metadata = await getTenantMetadataRemote(req, service);
-      } else if (cds.mtx && cds.env.requires && cds.env.requires.multitenancy) {
-        metadata = await getTenantMetadataLocal(req, service);
-      } else if (cds.env.requires && cds.env.requires["cds.xt.ModelProviderService"]) {
-        metadata = await getTenantMetadataStreamlined(req, service);
-      }
+    if (req.tenant && cds.env.requires?.["cds.xt.ModelProviderService"]) {
+      metadata = await getTenantMetadataStreamlined(req, service);
     }
     if (!metadata) {
       metadata = await getDefaultMetadata(req, service);
@@ -619,59 +604,6 @@ function cov2ap(options = {}) {
     return metadata;
   }
 
-  async function getTenantMetadataRemote(req, service) {
-    const mtxBasePath =
-      mtxEndpoint.startsWith("http://") || mtxEndpoint.startsWith("https://") ? mtxEndpoint : `${target}${mtxEndpoint}`;
-    return await prepareMetadata(
-      req.tenant,
-      async (tenant) => {
-        const response = await fetch(`${mtxBasePath}/metadata/csn/${tenant}`, {
-          method: "GET",
-          headers: propagateHeaders(req),
-        });
-        if (!response.ok) {
-          throw new Error(await response.text());
-        }
-        return response.json();
-      },
-      async (tenant, service, locale) => {
-        const response = await fetch(
-          `${mtxBasePath}/metadata/edmx/${tenant}?name=${service}&language=${locale}&odataVersion=v2`,
-          {
-            method: "GET",
-            headers: propagateHeaders(req),
-          }
-        );
-        if (!response.ok) {
-          throw new Error(await response.text());
-        }
-        return response.text();
-      },
-      service,
-      determineLocale(req)
-    );
-  }
-
-  async function getTenantMetadataLocal(req, service) {
-    proxyCache[req.tenant] = proxyCache[req.tenant] || {};
-    const isExtended = await callCached(proxyCache[req.tenant], "isExtended", () => {
-      return cds.mtx.isExtended(req.tenant);
-    });
-    if (isExtended) {
-      return await prepareMetadata(
-        req.tenant,
-        async (tenant) => {
-          return await cds.mtx.getCsn(tenant);
-        },
-        async (tenant, service, locale) => {
-          return await cds.mtx.getEdmx(tenant, service, locale, "v2");
-        },
-        service,
-        determineLocale(req)
-      );
-    }
-  }
-
   async function getTenantMetadataStreamlined(req, service) {
     const { "cds.xt.ModelProviderService": mps } = cds.services;
     proxyCache[req.tenant] = proxyCache[req.tenant] || {};

package/lib/srv/srv-api.js

@@ -63,10 +63,16 @@ class Service extends require('./srv-handlers') {
   run (query, data) {
     if (typeof query === 'function') {
       const ctx = cds.context, fn = query
-      if (ctx?.tx && !ctx.tx._done)
-        return fn (this.tx(ctx)) // run fn with nested tx
-      else return this.tx(fn)   // run fn with root tx
+
+      if (!ctx?.tx) return this.tx(fn)               // run fn with root tx
+      else {
+        if (!ctx.tx._done) return fn(this.tx(ctx))   // run fn with nested tx
+        else if (ctx.tx._done === 'rolled back')     // > reject
+          ctx.tx._throw_closed_error()
+        else return this.tx(fn)                      // run fn with detached root tx
+      }
     }
+
     const req = new Request ({ query, data })
     return this.dispatch (req)
   }

package/lib/srv/srv-dispatch.js

@@ -14,11 +14,14 @@ exports.dispatch = async function dispatch (req) { //NOSONAR
   // Ensure we are in a proper transaction
   if (!this.context) {
     const ctx = cds.context
-    if (ctx?.tx && !ctx.tx._done) {
-      return this.tx (ctx) .dispatch(req)      // with nested tx
-    }
 
-    return this.tx (tx => tx.dispatch(req))  // with root tx
+    if (!ctx?.tx) return this.tx(tx => tx.dispatch(req))     // with root tx
+    else {
+      if (!ctx.tx._done) return this.tx(ctx).dispatch(req)   // with nested tx
+      else if (ctx.tx._done === 'rolled back')               // > reject
+        ctx.tx._throw_closed_error()
+      else return this.tx(tx => tx.dispatch(req))            // with detached root tx
+    }
   }
 
   if (!req.tx) req.tx = this // `this` is a tx from now on...
@@ -57,14 +60,14 @@ exports.handle = async function handle (req) {
   handlers = this._handlers._initial.filter (h => h.for(req))
   if (handlers.length) {
     for (const each of handlers) await each.handler.call (this,req)
-    if (req.errors) throw req.errors.throwable()
+    if (req.errors) throw req.reject()
   }
 
   // .before handlers run in parallel
   handlers = this._handlers.before.filter (h => h.for(req))
   if (handlers.length) {
     await Promise.all (handlers.map (each => each.handler.call (this,req)))
-    if (req.errors) throw req.errors.throwable()
+    if (req.errors) throw req.reject()
   }
 
   // .on handlers run in parallel for async events, and as interceptors stack for sync requests
@@ -78,16 +81,16 @@ exports.handle = async function handle (req) {
       if (r.results)            return r.results
       if (srv._implicit_next)   return next()
     }()
-    if (req.errors) throw req.errors.throwable()
+    if (req.errors) throw req.reject()
   }
   else if (req.query) throw _unhandled (this,req)
 
   // .after handlers run in parallel
   handlers = this._handlers.after.filter (h => h.for(req))
   if (handlers.length) {
-    const results = cds.env.features.arrayed_after && req.event === 'READ' && !_is_array(req.results) ? [req.results] : req.results // REVISIT: remove this in a future release after some grace period
+    const results = req.event === 'READ' && !_is_array(req.results) ? (req.results == null ? [] : [req.results]) : req.results
     await Promise.all (handlers.map (each => each.handler.call (this, results, req)))
-    if (req.errors) throw req.errors.throwable()
+    if (req.errors) throw req.reject()
   }
 
   return req.results //> done

package/lib/srv/srv-models.js

@@ -24,7 +24,7 @@ class ExtendedModels {
     if (!(srv instanceof cds.ApplicationService)) return [] //> no middleware to add // REVISIT: move to `srv.isExtensible`
     if (!srv.isExtensible) return [] //> no middleware to add
     else return async function cds_context_model (req,res,next) {
-      if (!req.user?.tenant) return next()
+      if (!req.tenant && !req.user?.tenant && !req.features && !req.user?.features) return next()
       const ctx = cds.context = cds.EventContext.for({ http: { req, res } })
       ctx.user = req.user // REVISIT: should move to auth middleware?
       try {
@@ -161,7 +161,7 @@ class ExtendedModels {
   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
+  static checkInterval = cds.requires.extensibility?.tenantCheckInterval || 1 * 60 * 1000
 
   /** Time interval in ms after which to evict models for inactive tenants. */
   static sentinelInterval = cds.requires.extensibility?.evictionInterval || 3600*1000
@@ -169,21 +169,6 @@ class ExtendedModels {
 }
 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
 
@@ -195,10 +180,8 @@ if (!extensibility) {
 
 
 // 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) => {
-  return old_mtx.getCsn(tenant) .then (cds.compile.for.nodejs)
-} : (tenant, toggles) => {
+const _is_extended = extensibility ? ()=> cds.db.exists('cds.xt.Extensions') : ()=> false
+const _get_model4 = (tenant, toggles) => {
   const { 'cds.xt.ModelProviderService':mps } = cds.services
   return mps.getCsn (tenant, toggles) .then (cds.compile.for.nodejs)
 }

package/lib/srv/srv-tx.js

@@ -1,4 +1,4 @@
-const cds = require('../index'), { cds_tx_protection } = cds.env.features
+const cds = require('../index')
 const EventContext = require('../req/context')
 class RootContext extends EventContext {
   static for(_) {
@@ -26,13 +26,13 @@ function srv_tx (ctx,fn) { const srv = this
   if (!ctx) return RootTransaction.for (srv)
 
   // Creating root or nested txes for existing contexts
-  if (ctx instanceof EventContext) {
+  if (typeof ctx === 'function') [ ctx, fn ] = [ undefined, ctx ]
+  else if (ctx instanceof EventContext) {
     if (ctx.tx) return NestedTransaction.for (srv, ctx)
     else return RootTransaction.for (srv, ctx)
   }
 
   // Last arg may be a function -> srv.tx (tx => { ... })
-  if (typeof ctx === 'function') [ ctx, fn ] = [ undefined, ctx ]
   if (typeof fn === 'function') {
     const tx = RootTransaction.for (srv, ctx)
     return cds._context.run (tx, ()=> Promise.resolve(fn(tx)) .then (tx.commit, tx.rollback))
@@ -63,6 +63,7 @@ class Transaction {
     const proto = new.target.prototype
     tx.commit   = proto.commit.bind(tx)
     tx.rollback = proto.rollback.bind(tx)
+    tx._throw_closed_error = proto._throw_closed_error.bind(tx)
     if (srv.isExtensible) {
       const m = cds.context?.model
       if (m) tx.model = m
@@ -105,6 +106,13 @@ class Transaction {
     if (err) throw err
   }
 
+  _throw_closed_error () {
+    throw cds.error (
+      `Transaction is ${this._done}, no subsequent .run allowed, without prior .begin`,
+      { code: 'TRANSACTION_CLOSED' }
+    )
+  }
+
 }
 
 
@@ -124,7 +132,7 @@ class RootTransaction extends Transaction {
    * are informed by emitting 'succeeded' event to them all.
    */
   async commit (res) {
-    if (cds_tx_protection) this._done = 'committed'
+    this._done = 'committed'
     try {
       await this.context.emit ('commit',res) //> allow custom handlers req.before('commit')
       await super.commit (res)
@@ -144,7 +152,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._done = 'rolled back'
+    this._done = 'rolled back'
     try {
       await this.context.emit ('failed',err)
       await super.rollback (err)
@@ -191,13 +199,8 @@ 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 root tx.commit/rollback()
-  if (typeof this.ready === 'string' || !this.ready && this.context.tx._done) {
-    if (!cds_tx_protection) this.ready = this.begin() // compatibility to former behavior, which allowed tx.run() after commit/rollback
-    else throw cds.error (
-      `Transaction is ${this.ready || this.context.tx._done}, no subsequent .run allowed, without prior .begin`,
-      { code: 'TRANSACTION_CLOSED' }
-    )
-  }
+  if (typeof this.ready === 'string' || !this.ready && this.context.tx._done)
+    this.context.tx._throw_closed_error()
   else if (!this.ready) this.ready = this.begin()
   await this.ready
   delete this.dispatch

package/lib/utils/cds-test.js

@@ -9,23 +9,28 @@ class Test extends require('./axios') {
   run (cmd='.', ...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}'`)
+    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}'`)
+      }
+    } else if ('run' === cmd && args.length > 0) { // `run <project>` -> `serve --project <project>`
+      if (!args.includes('--project')) args.unshift('--project')
     }
 
     // launch cds server...
-    before (`launching ${cmd} ${args.join(' ')}...`, () => {
+    before (`launching ${cmd} ${args.join(' ')}...`, async () => {
+      await cds.plugins
       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, ...(args.includes('--port') ? [] : ['--port', '0'])) }
+      try { return cds.exec (...args, ...(args.includes('--port') ? [] : ['--port', '0'])) }
       catch (e) { if (is_mocha) console.error(e) } // eslint-disable-line no-console
     })
 
@@ -112,7 +117,7 @@ function support_jest_and_mocha() {
     global.beforeEach = ()=>{}
     global.afterEach = ()=>{}
     global.after = global.afterAll = (fn) => {
-      const repl = global.cds.repl
+      const repl = global.cds?.repl
       repl && repl.on('exit',fn)
     }
   }

package/lib/utils/cds-utils.js

@@ -102,7 +102,7 @@ exports.read = async function read (file, _encoding) {
 exports.write = function write (file, data, o) {
   if (arguments.length === 1) return {to:(...path) => write(join(...path),file)}
   if (typeof data === 'object' && !Buffer.isBuffer(data))
-    data = JSON.stringify(data, null, ' '.repeat(o && o.spaces)) + require('os').EOL
+    data = JSON.stringify(data, null, ' '.repeat(o && o.spaces)) + '\n'
   const f = resolve (cds.root,file)
   return fs.mkdirp (dirname(f)).then (()=> fs.promises.writeFile (f,data,o))
 }
@@ -178,17 +178,7 @@ exports.find = function find (base, patterns='*', filter=()=>true) {
   return files
 }
 
-// TODO find a better place
-exports._oldMtx = function _oldMtx() {
-  function _hasMtxDependency() {
-    try {
-      return require(join(cds.root, 'package.json'))?.dependencies?.['@sap/cds-mtx']
-    } catch(e) {
-      return false
-    }
-  }
-  return (_hasMtxDependency() || process.env.OLD_MTX?.toLowerCase() === 'true') ?? false
-}
+exports.csv = require('./csv-reader')
 
 /**
  * Internal utility to load a file through ESM or CommonJs.  TODO find a better place.

package/lib/utils/check-version.js

@@ -0,0 +1,17 @@
+const major_minor = version => {
+  let [ major, minor ] = version.split('.').map(x => +x)
+  return { version, major, minor }
+}
+const required = major_minor(
+  require('../../package.json').engines.node.match(/>=(.*)/)[1]
+)
+const given = major_minor(
+  process.version.match(/^v(\d+\.\d+)/)[1]
+)
+
+if (given.major < required.major || given.major === required.major && given.minor < required.minor) process.exit (
+  process.stderr.write (`
+  Node.js v${required.version} or higher is required for @sap/cds.
+  Current v${given.version} does not satisfy this.
+  \n`
+) || 1)

package/{bin/build → lib/utils}/csv-reader.js

@@ -1,52 +1,51 @@
-const {createReadStream, createWriteStream, readFile:rf} = require('fs')
-const readFile = require('util').promisify(rf)
-const {Readable} = require('stream')
+const { createReadStream, createWriteStream, promises: fsp } = require('fs')
+const { Readable } = require('stream')
 const cds = require('../../lib')
 
 const SEPARATOR = /[,;\t]/
 module.exports = { parse: cds.parse.csv, readHeader, stripComments, serialize }
 
 
-function serialize (rows, columns, bom='\ufeff') {
-  let csv = bom + ( columns || Object.keys(rows[0]) ).join(';') +"\n"
-  for (let key in rows)  csv += `${key};${rows[key]}\r\n`
+function serialize(rows, columns, bom = '\ufeff') {
+  let csv = bom + (columns || Object.keys(rows[0])).join(';') + "\n"
+  for (let key in rows) csv += `${key};${rows[key]}\r\n`
   return csv
 }
 
-async function readHeader (inStream, o={ignoreComments:true}) {
+async function readHeader(inStream, o = { ignoreComments: true }) {
   let delimiter = ';'
   let cols = []
   let filtered = false
-  await _filterLines (inStream, null, (line, readLine) => {
+  await _filterLines(inStream, null, (line, readLine) => {
     if (!cols.length) {
       if (o.ignoreComments && _ignoreLine(line)) {
         filtered = true
         return false
       }
-      [delimiter] = SEPARATOR.exec(line)||[';']
-      cols = line.split(delimiter) .map (each => each.trim()) .filter(each=>each.length)
+      [delimiter] = SEPARATOR.exec(line) || [';']
+      cols = line.split(delimiter).map(each => each.trim()).filter(each => each.length)
       readLine.close() // signal that we have seen enough --> this only ends the readLine interface
     }
     return true
   })
 
   inStream.destroy() // destroy the stream to avoid leaks of file descriptors
-  return {cols, delimiter, filtered}
+  return { cols, delimiter, filtered }
 }
 
 async function stripComments(file, outStream) {
   // most files don't need filtering, so do a quick check first
   const { filtered } = await readHeader(createReadStream(file))
-  if (!filtered)  return false
+  if (!filtered) return false
 
   // buffer whole content so that we can write the out file
-  const inStream = Readable.from([await readFile(file)])
+  const inStream = Readable.from([await fsp.readFile(file)])
   // clears the output file
   outStream = outStream || createWriteStream(file)
   let prelude = true
-  await _filterLines (inStream, outStream, line => {
+  await _filterLines(inStream, outStream, line => {
     if (prelude) {
-      if (_ignoreLine(line))  return false
+      if (_ignoreLine(line)) return false
       prelude = false
     }
     // skip empty lines - HANA cannot handle them, e.g. at end of the file
@@ -59,14 +58,14 @@ function _ignoreLine(line) {
   return line[0] === '#' || !line.trim().length
 }
 
-function _filterLines (input, out, filter) {
-  return new Promise((resolve, reject)=> {
-    const rl = require('readline').createInterface({input, crlfDelay: Infinity})
+function _filterLines(input, out, filter) {
+  return new Promise((resolve, reject) => {
+    const rl = require('readline').createInterface({ input, crlfDelay: Infinity })
     const resumeOnDrain = () => rl.resume()
     let filtered = false
-    rl.on ('line', line => {
-      if (filter (line, rl)) {
-        if (out && !out.write (line+'\n')) {
+    rl.on('line', line => {
+      if (filter(line, rl)) {
+        if (out && !out.write(line + '\n')) {
           rl.pause() // pause when writable signals so
           out.removeListener('drain', resumeOnDrain) // avoid too many listeners
           out.once('drain', resumeOnDrain)
@@ -74,8 +73,8 @@ function _filterLines (input, out, filter) {
       }
       else filtered |= true
     })
-    rl.on ('error', reject)
-    rl.on ('close', () => out ? out.end() : resolve(filtered))
-    if (out)  out.on('finish', () => resolve(filtered))
+    rl.on('error', reject)
+    rl.on('close', () => out ? out.end() : resolve(filtered))
+    if (out) out.on('finish', () => resolve(filtered))
   })
 }