@sap/cds 8.9.4 → 9.0.2

package/lib/srv/srv-handlers.js

@@ -1,7 +1,4 @@
-/** @typedef {import('./cds.Service')} Service } */
-
-const cds = require('..'), {expected} = cds.error
-const LOG = cds.log()
+const cds = require('..')
 
 class EventHandlers {
 
@@ -24,19 +21,21 @@ class EventHandlers {
   //--------------------------------------------------------------------------
   /** Registers event handlers. This is the central method to register handlers,
    * used by all respective public API methods, i.e. .on/before/after/reject.
+   * @import Service from './cds.Service'
+   * @import Request from '../req/request'
    * @param {Service} srv
    * @param {'on'|'before'|'after'} phase
    * @param {string|string[]} event
    * @param {string|string[]} path
-   * @param {(req)=>{}} handler
+   * @param {(req:Request)=>{}} handler
    */
   register (srv, phase, event, path, handler) {
 
     if (!handler) [ handler, path ] = [ path, '*' ] // argument path is optional
-    else if (path === undefined) expected `${{path}} to be a string or csn definition`
-    if (typeof handler !== 'function') expected `${{handler}} to be a function`
+    else if (path === undefined) cds.error.expected `${{path}} to be a string or csn definition`
+    if (typeof handler !== 'function') cds.error.expected `${{handler}} to be a function`
     if (handler._is_stub) {
-      LOG.warn (`\n
+      cds.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.
@@ -64,9 +63,9 @@ class EventHandlers {
     }
     else if (typeof event === 'object') {
       // extract action name from an action definition's fqn
-      event = event.name && /[^.]+$/.exec(event.name)[0] || expected `${{event}} to be a string or an action's CSN definition`
+      event = event.name && /[^.]+$/.exec(event.name)[0] || cds.error.expected `${{event}} to be a string or an action's CSN definition`
     }
-    else event = AlternativeEvents[event] || event
+    else event = events[event] || event
 
     // Canonicalize path argument
     if (!path || path === '*') path = undefined
@@ -75,25 +74,12 @@ class EventHandlers {
       return srv
     }
     else if (typeof path === 'object') {
-      path = path.name || expected `${{path}} to be a string or an entity's CSN definition`
+      path = path.name || cds.error.expected `${{path}} to be a string or an entity's CSN definition`
     }
     else if (typeof path === 'string') {
       if (!path.startsWith(srv.name+'.')) path = `${srv.name}.${path}`
     }
 
-    if (cds.env.fiori.draft_compat) {
-      const entity = path && srv.model?.definitions[path.name || path]
-      if (['PATCH', 'CANCEL', 'NEW'].includes(event)) {
-        // delegate to drafts
-        path = typeof path === 'string' && path !== '*' && !path.endsWith('.drafts') ? path + '.drafts' : typeof path === 'object' && path.drafts || path
-        if (event === 'PATCH') event = 'UPDATE'
-      }
-      else if (entity && (event === 'READ' || entity.actions?.[event]) && (entity.drafts && !entity.name.endsWith('.drafts'))) {
-        // additionally add drafts for READ and bound actions/functions
-        this.register (srv, phase, event, entity.name + '.drafts', handler)
-      }
-    }
-
     // Finally register with a filter function to match requests to be handled
     const handlers = event === 'error' ? this._error : handler._initial ? this._initial : this[phase] // REVISIT: remove _initial handlers
     handlers.push (new EventHandler (phase, event, path, handler))
@@ -101,22 +87,7 @@ class EventHandlers {
     if (phase === 'on') cds.emit('subscribe',srv,event) //> inform messaging service
     return srv
   }
-
-
-  //--------------------------------------------------------------------------
-  // EXPERIMENTAL: It is not decided yet, whether we should keep the stuff below
-  // => Please do not use anywhere!
-  onSucceeded (...args) { return _req_on (this, 'succeeded', ...args) }
-  onFailed (...args) { return _req_on (this, 'failed', ...args) }
-  for (event, path) { //> fetch all handlers for the given event and path
-    const filtered = {}
-    for (let each in this) {
-      filtered[each] = this[each].filter (h => h.for({event,path}))
-    }
-    return filtered
-  }
 }
-module.exports = EventHandlers
 
 
 class EventHandler {
@@ -132,22 +103,19 @@ class EventHandler {
     if (event && path) return req => event === req.event && (path === req.path || path === req.entity)
     if (event) return req => event === req.event
     if (path) return req => path === req.path || path === req.entity
-    else return () => true
+    else return req => !req.event?.includes('/#')
   }
 }
 
 
 const is_array = Array.isArray
-const AlternativeEvents = {
+const events = {
   SELECT: 'READ',
   GET: 'READ',
   PUT: 'UPDATE',
   POST: 'CREATE',
+  PATCH: 'UPDATE',
   INSERT: 'CREATE',
 }
 
-
-const _req_on = (srv, succeeded_or_failed, event, path, handler) => {
-  if (!handler) [path,handler] = [undefined,path]
-  return srv.before (event,path, req => req.on(succeeded_or_failed,handler))
-}
+module.exports = EventHandlers

package/lib/srv/srv-methods.js

@@ -1,24 +1,19 @@
-/** @typedef {import('./cds.ServiceClient')} Service } */
-
 const cds = require('..')
 const LOG = cds.log('cds.serve',{label:'cds'})
 
-
+/** @import Service from './cds.Service' */
 /** @param {Service} srv */
-module.exports = function (srv=this) {
-  if (!srv.definition) return //> can only add shortcuts for actions declared in service models
-  if (!srv.isAppService && !srv.isExternal && !srv._add_stub_methods) return
-  for (const each of srv.actions) {
-    add_handler_for (srv, each)
-  }
-  for (const each of srv.entities) {
-    for (const a in each.actions) {
-      add_handler_for (srv, each.actions[a])
-    }
+module.exports = function (srv = this) {
+  if ( !srv.definition ) return //> can only add shortcuts for actions declared in service models
+  if ( srv.isAppService || srv.isExternal || srv._add_stub_methods ) {
+    for (const each of srv.actions)
+      add_handler_for (srv, each)
+    for (const each of srv.entities)
+      for (const a in each.actions)
+        add_handler_for (srv, each.actions[a])
   }
 }
 
-
 /** @param {Service} srv */
 const add_handler_for = (srv, def) => {
   const event = def.name.match(/\w*$/)[0]
@@ -32,7 +27,7 @@ const add_handler_for = (srv, def) => {
       srv.__proto__ === cds.RemoteService.prototype ? srv.__proto__ :
       srv.__proto__.__proto__ // in case of class-based impls
     )
-    if (method.name in baseclass) return LOG.warn(`WARNING: custom ${def.kind} '${event}()' conflicts with method in base class.
+    if (event in baseclass) return LOG.warn(`WARNING: custom ${def.kind} '${event}()' conflicts with method in base class.
 
       Cannot add typed method for custom ${def.kind} '${event}' to service impl of '${srv.name}',
       as this would shadow equally named method in service base class '${baseclass.constructor.name}'.
@@ -62,41 +57,24 @@ const add_handler_for = (srv, def) => {
       this.model.definitions[ $.name ]
       || this.entities[ $.name?.replace(`${this.name}.`,'') || $ ]
     )
-    if (target) {                        //> bound action/function?
+    if (target) {                       //> bound action/function?
       req.target = target; args.shift() // first argument is the target entity name
-      req.params = [ args.shift() ]    // second argument is the target's primary key
+      req.params = [ args.shift() ]     // second argument is the target's primary key
+      if (_consistent_params && typeof req.params[0] !== 'object')
+        req.params = [{ [Object.keys(target.keys)[0]]: req.params[0] }]
     }
     const {params} = target ? target.actions[event] : def
     if (params) req.data = _named(args,params) || _positional(args,params)
 
-    // ensure legacy compat, keys in req.data
-    if(cds.env.features.keys_in_data_compat && target) {
-      cds.utils.deprecated({ old: 'flag cds.env.features.keys_in_data_compat'})
-      // named/positional variant of keys
-      const named = req.params.length === 1 && typeof req.params[0] === 'object'
-
-      let pos = 0 //> counter for key in positional variant
-      for (const k in target.keys) {
-        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.
-          `)
-        }
-        req.data[k] = named ? req.params[0][k] : req.params[pos++]
-      }
-
-    }
-
     return this.send (req)
   }
   Object.defineProperties(stub,{
     name: {value: /[^.]+$/.exec(srv.name)[0] +'.'+ event},
     _is_stub: {value:true},
   })
+  const _consistent_params = cds.env.features.consistent_params //> remove with cds^10
 }
 
-
 const _named = (args, declared) => {
   if (args.length > 1) return
   const a = args[0]

package/lib/srv/srv-tx.js

@@ -1,19 +1,9 @@
 /** @typedef {import('./cds.Service')} Service } */
 
-const cds = require('../index')
+const cds = require('../index'), { srv_tx_compat_for_afc = true } = cds.env.features
 const EventContext = require('../req/context')
-class RootContext extends EventContext {
-  static for(_) {
-    if (_ instanceof EventContext) return _
-    else return super.for(_,'as root')
-  }
-}
-class NestedContext extends EventContext {
-  static for(_) {
-    if (_ instanceof EventContext) return _
-    else return super.for(_)
-  }
-}
+class RootContext extends EventContext { static for(_) { return _ instanceof EventContext ? _ : super.for(_,'as root') } }
+class NestedContext extends EventContext { static for(_) { return _ instanceof EventContext ? _ : super.for(_) } }
 
 
 /**
@@ -24,25 +14,30 @@ class NestedContext extends EventContext {
  */
 module.exports = exports = function srv_tx (ctx,fn) { const srv = this
 
-  if (srv.context) return srv // srv.tx().tx() -> idempotent
+  // srv.tx().tx() -> idempotent no-op (questionable: ignoring all futher arguments)
+  if (srv.context) return srv
+
+  // Usage variant 1: srv.tx() -> get root tx for a service
   if (!ctx) return RootTransaction.for (srv)
 
-  // Creating root or nested txes for existing contexts
+  // Usage variant 2: srv.tx (fn) -> run fn in a new root tx
   if (typeof ctx === 'function') [ ctx, fn ] = [ undefined, ctx ]
-  else if (ctx instanceof EventContext) {
+  if (typeof fn === 'function') {
+    const tx = RootTransaction.for (srv, ctx)
+    return cds._with (tx, ()=> Promise.resolve(fn(tx)) .then (tx.commit, tx.rollback))
+  }
+
+  // Usage variant 3: srv.tx (req) -> LEGACY way of propagating tx before cds.context
+  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 fn === 'function') {
-    const tx = RootTransaction.for (srv, ctx)
-    return cds._context.run (tx, ()=> Promise.resolve(fn(tx)) .then (tx.commit, tx.rollback))
+  // Usage variant 4: srv.tx ({...}) -> get a new root tx for a service
+  if (srv_tx_compat_for_afc) { // REVISIT: compatibility for AFC only -> we should get rid of that
+    if (ctx._txed_before) return NestedTransaction.for (srv, ctx._txed_before)
+    else Object.defineProperty (ctx, '_txed_before', { value: ctx = RootContext.for(ctx) })
   }
-
-  // REVISIT: following is for compatibility with AFC only -> we should get rid of that
-  if (ctx._txed_before) return NestedTransaction.for (srv, ctx._txed_before)
-  else Object.defineProperty (ctx, '_txed_before', { value: ctx = RootContext.for(ctx) })
   return RootTransaction.for (srv, ctx)
 }
 
@@ -54,7 +49,6 @@ class Transaction {
    */
   static for (srv, ctx) {
     const txs = ctx.context.transactions || ctx.context._set ('transactions', new Map)
-    if (srv._real_srv) srv = srv._real_srv // REVISIT: srv._real_srv is a dirty hack for current Okra Adapters
     let tx = txs.get (srv)
     if (!tx) txs.set (srv, tx = new this (srv,ctx))
     return tx

package/lib/test/cds-test.js

@@ -1,264 +1,5 @@
-module.exports = require_local('@cap-js/cds-test')
+// Overwrite require to support IntelliSense in VS Code...
+const {resolve} = require, paths = [ process.cwd(),  __dirname ]
+require = id => module.require (resolve(id,{paths})) // eslint-disable-line no-global-assign
 
-// TODO remove the code below with cds 9
-if (!module.exports) {
-
-const { RED, RESET } = require('../utils/colors')
-// eslint-disable-next-line no-console
-console.error(RED+'Test support will move to package @cap-js/cds-test in @sap/cds v9.\nGet ready and add a dependency to it:\n  npm add -D @cap-js/cds-test\n'+RESET)
-
-/**
- * Instances of this class are constructed and returned by cds.test().
- */
-class Test extends require('./axios') {
-
-  /**
-   * Allows: const { GET, expect, test } = cds.test()
-   */
-  test = this
-
-  get cds() { return require('../index') }
-  get sleep() { return super.sleep = require('util').promisify(setTimeout) }
-  get data() { return super.data = new (require('./data'))}
-
-  /**
-   * Launches a cds server with arbitrary port and returns a subclass which
-   * also acts as an axios lookalike, providing methods to send requests.
-   */
-  run (folder_or_cmd, ...args) {
-
-    switch (folder_or_cmd) {
-      case 'serve': break // nothing to do as all arguments are given
-      case 'run': if (args.length > 0) args.unshift('--project'); break
-      default: this.in(folder_or_cmd); args.push('--in-memory?')
-    }
-    const {cds} = this
-
-    // launch cds server...
-    before (async ()=>{
-      process.env.cds_test_temp = cds.utils.path.resolve(cds.root,'_out',''+process.pid)
-      if (!args.includes('--port')) args.push('--port', '0')
-      let { server, url } = await cds.exec(...args)
-      this.server = server
-      this.url = url
-    })
-
-    // gracefully shutdown cds server...
-    after (async ()=>{
-      await cds.shutdown()
-      // cds.service.providers = []
-      // delete cds.services
-      // delete cds.plugins
-      // delete cds.env
-      await cds.utils.rimraf (process.env.cds_test_temp)
-    })
-
-    return this
-  }
-
-  /**
-   * Serving projects from subfolders under the root specified by a sequence
-   * of path components which are concatenated with path.resolve().
-   * Checks conflicts with cds.env loaded in other folder before.
-   */
-  in (folder, ...paths) {
-    if (!folder) return this
-    const {cds} = this, { isdir, local } = cds.utils
-    // try to resolve folder relative to cds.root, or as a node module
-    try {
-      const path = require('path')
-      folder = isdir (path.resolve (cds.root, folder, ...paths))
-      || path.join (require.resolve (folder+'/package.json').slice(0,-13), ...paths)
-    } catch {
-      throw cds.error (`No such folder or package '${process.cwd()}' -> '${folder}'`)
-    }
-    // Check if cds.env was loaded before running cds.test in different folder
-    if (process.env.CDS_TEST_ENV_CHECK) {
-      const env = Reflect.getOwnPropertyDescriptor(cds,'env')?.value
-      if (env && env._home !== folder && env.stack) {
-        let filter = line => !line.match(/node_modules\/jest-|node:internal/)
-        let err = new Error; err.message =
-          `Detected cds.env loaded before running cds.test in different folder: \n` +
-          `1. cds.env loaded from:  ${local(cds.env._home)||'./'} \n` +
-          `2. cds.test running in:  ${local(folder)} \n\n` +
-          err.stack.split('\n').filter(filter).slice(1).join('\n')
-        err.stack = env.stack.split('\n').filter(filter).slice(1).join('\n')
-        throw err
-      }
-    }
-    cds.root = folder
-    return this
-  }
-
-  /**
-   * Method to spy on a function in an object, similar to jest.spyOn().
-   */
-  spy (o,f) {
-    const origin = o[f]
-    const fn = function (...args) {
-      ++fn.called
-      return origin.apply(this,args)
-    }
-    fn.called = 0
-    fn.restore = ()=> o[f] = origin
-    return o[f] = fn
-  }
-
-  /**
-   * For usage in repl, e.g. var test = await cds.test()
-   */
-  then (resolve) {
-    if (this.server) {
-      resolve({ server: this.server, url: this.url })
-    } else {
-      this.cds.once('listening', resolve)
-    }
-  }
-
-  /**
-   * Captures console.log output.
-   */
-  log (_capture) {
-    const {console} = global, {format} = require('util')
-    const log = { output: '' }
-    beforeAll(()=> global.console = { __proto__: console,
-      log: _capture ??= (..._)=> log.output += format(..._)+'\n',
-      info: _capture,
-      warn: _capture,
-      debug: _capture,
-      trace: _capture,
-      error: _capture,
-      timeEnd: _capture, time: ()=>{},
-    })
-    afterAll (log.release = ()=>{ log.output = ''; global.console = console })
-    afterEach (log.clear = ()=>{ log.output = '' })
-    return log
-  }
-
-  /**
-   * Silences all console log output, e.g.: CDS_TEST_SILENT=y jest/mocha ...
-   */
-  silent(){
-    global.console = { __proto__: console,
-      log: ()=>{},
-      info: ()=>{},
-      warn: ()=>{},
-      debug: ()=>{},
-      trace: ()=>{},
-      error: ()=>{},
-      time: ()=>{},
-      timeEnd: ()=>{},
-    }
-    return this
-  }
-  /** @deprecated */ verbose(){ return this }
-
-
-  /**
-   * Lazily loads and returns an instance of chai
-   */
-  get chai() {
-    const chai = require('chai')
-    chai.use (require('chai-subset'))
-    const chaip = require('chai-as-promised')
-    chai.use (chaip.default/*v8 on ESM*/ ?? chaip/*v7*/)
-    return chai
-    function require (mod) { try { return module.require(mod) } catch(e) {
-      if (e.code === 'MODULE_NOT_FOUND')
-        throw new Error (`Failed to load required package '${mod}'. Please add it thru:`
-        + `\n  npm add -D chai chai-as-promised chai-subset`, {cause: e})
-      else if (e.name === 'SyntaxError') // Jest stumbling over ESM
-        throw new Error (`Jest failed to load ESM package '${mod}'.`
-        + `\nDowngrade '${mod}' to the major version before, or use a different test runner like 'node --test'.\n`, {cause: e})
-      else if (e.code === 'ERR_REQUIRE_ESM') // node --test on older Node versions
-        throw new Error (`Failed to load ESM package '${mod}'. This only is supported on Node.js >= 23.`
-          + `\nUpgrade your Node.js installation or downgrade '${mod}' to the major version before.\n`, {cause: e})
-      else throw e
-    }}
-  }
-  set expect(x) { super.expect = x }
-  get expect() { return this.chai.expect }
-  get assert() { return this.chai.assert }
-  get should() { return this.chai.should() }
-}
-
-
-/** @type Test & ()=>Test */
-module.exports = exports = Object.assign ((..._) => (new Test).run(..._), { Test })
-
-// Set prototype to allow usages like cds.test.in(), cds.test.log(), ...
-Object.setPrototypeOf (exports, Test.prototype)
-
-
-// Provide same global functions for jest and mocha
-;(function _support_jest_and_mocha() {
-  const _global = p => Object.getOwnPropertyDescriptor(global,p)?.value
-  const is_jest = _global('beforeAll')
-  const is_mocha = _global('before')
-  const repl = global.cds?.repl || process.env.CDS_TEST_FAKE // for crazy forks in some cds-dk and mtxs tests ;)
-  if (repl) { // it's cds repl
-
-    global.beforeAll  = global.before    = (msg,fn) => (fn||msg)()
-    global.afterAll   = global.after     = (msg,fn) => repl.on?.('exit',fn||msg)
-    global.beforeEach = global.afterEach = ()=>{}
-    global.describe   = ()=>{}
-    global.expect = require('./expect')
-
-  } else if (is_mocha) { // it's mocha
-
-    global.describe.each = global.it.each = each
-    global.beforeAll = before
-    global.afterAll = after
-    global.test = it
-    global.xtest = test.skip
-    global.xdescribe = describe.skip
-    process.env.CDS_TEST_SILENT == 'false' || exports.silent()
-
-  } else if (is_jest) { // it's jest
-
-    global.before = (msg,fn) => global.beforeAll(fn||msg)
-    global.after  = (msg,fn) => global.afterAll(fn||msg)
-
-  } else { // it's node --test
-
-    const { describe, suite, test, before, after, beforeEach, afterEach } = require('node:test')
-    describe.each = test.each = describe.skip.each = test.skip.each = each
-    global.describe = describe; global.xdescribe = describe.skip
-    global.test = global.it = test; global.xtest = test.skip
-    global.beforeAll = global.before = (msg,fn=msg) => {
-      if (fn.length > 0) { const f = fn; fn = (_,done)=>f(done) }
-      return before(fn) // doesn't work for some reason
-    }
-    // global.beforeAll = global.before = (msg,fn) => {
-    //   if (!fn) [msg,fn] = ['',msg]
-    //   return test('<before> '+ msg, (_,done) => fn(done))
-    // }
-    global.afterAll = global.after = (msg,fn) => after(fn||msg)
-    global.beforeEach = beforeEach
-    global.afterEach = afterEach
-    global.expect = require('./expect')
-    // suite was introduced in Node 22
-    suite?.('<next>', ()=>{}) //> to signal the start of a test file
-
-  }
-
-  // required for test.each in mocha and node --test
-  function each (table) {
-    const {format} = require('util')
-    return (msg,fn) => Promise.all (table.map (each => {
-      if (!Array.isArray(each))  each = [each]
-      return this (format(msg,...each), ()=> fn(...each))
-    }))
-  }
-})()
-
-}
-
-function require_local(id) {
-  const cds = require('..')
-  try {
-    return require(require.resolve(id, { paths: [cds.root, __dirname] }))
-  } catch (e) {
-    if (e.code !== 'MODULE_NOT_FOUND')  throw e
-  }
-}
+module.exports = require ('@cap-js/cds-test')

package/lib/utils/cds-utils.js

@@ -18,9 +18,9 @@ exports = module.exports = new class {
     return super.format = format
   }
   get uuid() { return super.uuid = require('crypto').randomUUID }
-  get yaml() { return super.yaml = require('@sap/cds-foss').yaml }
-  get pool() { return super.pool = require('@sap/cds-foss').pool }
+  get yaml() { const yaml = require('js-yaml'); return super.yaml = Object.assign(yaml,{parse:yaml.load}) }
   get tar()  { return super.tar = process.platform === 'win32' && _tarLib() ? require('./tar-lib') : require('./tar') }
+  get _unit()  { return super._unit = require('./unit') }
 }
 
 /** @type {import('node:path')} */
@@ -52,6 +52,22 @@ exports.results = oa => {
 }
 
 
+/**
+ * Simple helper to deep-merge two or more objects.
+ * Entries from `xs` overwrite entries in `o`.
+ * @example cds.utils.merge({foo:1},{bar:2},{baz:3})
+ * @returns `o` with entries from `xs` merged in.
+ */
+exports.merge = function merge (o,...xs) {
+  let v; for (let x of xs) for (let k in x)
+    if (k === '__proto__' || k === 'constructor') continue //> avoid prototype pollution
+    else o[k] = is_object(v=x[k]) ? merge(o[k]??={},v) : v
+  return o
+}
+const is_object = x => typeof x === 'object' && x !== null && !is_array(x)
+const is_array = Array.isArray
+
+
 /**
  * Should be used in data providers, i.e., db services to return single
  * rows in response to SELECT.one queries.

package/lib/utils/tar.js

@@ -80,8 +80,8 @@ const tarInfo = async (info) => {
 
 const logDebugTar = async () => {
   const LOG = cds.log('tar')
-  if (!LOG?._debug) return 
-  try {    
+  if (!LOG?._debug) return
+  try {
     LOG (`tar path: ${await tarInfo('path')}`)
     LOG (`tar version: ${await tarInfo('version')}`)
   } catch (err) {
@@ -113,7 +113,7 @@ const logDebugTar = async () => {
  * - `.then()` collects the tar output into an in-memory `Buffer`
  * - `.to()` is a convenient shortcut to pipe the output into a write stream
  */
-exports.create = async (dir='.', ...args) => {
+exports.create = (dir='.', ...args) => {
   logDebugTar()
   if (typeof dir === 'string') dir = _resolve(dir)
   if (Array.isArray(dir)) [ dir, ...args ] = [ cds.root, dir, ...args ]
@@ -127,9 +127,7 @@ exports.create = async (dir='.', ...args) => {
     }
     args.push('.')
     if (Array.isArray(args[0])) {
-      temp = await createTemp(dir, args[0])
-      args.shift()
-      c = spawnDir(temp, args)
+      c = createTemp(dir, args.shift()) .then (t => spawnDir(t,args))
     } else {
       c = spawnDir(dir, args)
     }
@@ -210,7 +208,7 @@ exports.extract = (archive, ...args) => ({
     const x = spawn('tar', ['xf', win(input), '-C', win(dest), ...args])
     if (archive === '-') return x.stdin
     if (Buffer.isBuffer(archive)) archive = require('stream').Readable.from (archive)
-    if (typeof archive !== 'string') archive.pipe (x.stdin)
+    if (typeof archive !== 'string') (archive.stdout || archive) .pipe (x.stdin)
     let stdout='', stderr=''
     x.stdout.on ('data', d => stdout += d)
     x.stderr.on ('data', d => stderr += d)
@@ -269,7 +267,7 @@ exports.t = tar.tf = tar.list
  * @example fs.createReadStream('t.tar') .pipe (tar.x.to('dest/dir'))
  * @returns `stdin` of the tar child process
  */
- exports.extract.to = function (..._) { return this().to(..._) }
+ exports.extract.to = function (..._) { return this('-').to(..._) }
 
 
 

package/lib/utils/unit.js

@@ -0,0 +1,19 @@
+module.exports.time2ms = timeout => {
+  const match = timeout.match(/^([0-9]+)(w|d|h|hrs|min)$/)
+  if (!match) return
+
+  const [, val, t] = match
+  switch (t) {
+    case 'w':
+      return val * 1000 * 3600 * 24 * 7
+    case 'd':
+      return val * 1000 * 3600 * 24
+    case 'h':
+    case 'hrs':
+      return val * 1000 * 3600
+    case 'min':
+      return val * 1000 * 60
+    default:
+      return val
+  }
+}

package/libx/_runtime/.eslintrc

@@ -4,7 +4,7 @@
     "jest": true
   },
   // "extends": ["prettier-standard"],
-  "ignorePatterns": ["**/okra/**/*.js"],
+  "ignorePatterns": [],
   "rules": {
     "no-console": ["error"],
     "complexity": ["error"], // > default threshold: 20