@sap/cds 6.7.2 → 6.8.1

package/lib/dbs/cds-deploy.js

@@ -4,6 +4,18 @@ const GREY = COLORS ? '\x1b[2m' : ''
 const RESET = COLORS ? '\x1b[0m' : ''
 const DEBUG = cds.debug('deploy')
 const TRACE = cds.debug('trace')
+const nativeSchevoSqls = {
+  'postgres': {
+    create: `CREATE table cds_model (csn text)`,
+    insert: `INSERT into cds_model values ('null')`,
+    drop: `DROP table if exists cds_model;`
+  },
+  'sqlite': {
+    create: `CREATE table cds_Model (csn CLOB)`,
+    insert: `INSERT into cds_Model values ('null')`,
+    drop: `DROP table if exists cds_Model;`
+  }
+}
 
 /**
  * Implementation of `cds.deploy` common to all databases.
@@ -96,23 +108,34 @@ exports.exclude_external_entities_in = function (csn) { // NOSONAR
 
 
 exports.create = async function cds_deploy_create (db, csn=db.model, o) {
+  // REVISIT: How to find out if we use better-sqlite?
+  if (db._source === '@cap-js/sqlite') {
+    // it's required to set both properties
+    o.betterSqliteSessionVariables = true
+    o.sqlDialect = 'sqlite'
+  }
 
+  const sqls = nativeSchevoSqls[db.options?.dialect || db.options?.kind || 'sqlite'];
   let drops, creas, schevo = db.options?.schema_evolution === 'auto' || o.schema_evolution === 'auto'
   if (schevo) {
     // REVISIT: replace by db-specific ways to read/updated recent deployed model
-    let before = await db.run (async tx => { try {
-      let [{ csn }] = await tx.run('SELECT csn from cds_Model')
-      return JSON.parse(csn)
-    } catch(e) { if (!e.message.includes('no such table')) throw e
-      await tx.run(`CREATE table cds_Model (csn CLOB)`)
-      await tx.run(`INSERT into cds_Model values ('null')`)
-    }})
-    const { afterImage, drops:_drops, createsAndAlters:_creas } = cds.compile.to.sql.delta (csn, o, before)
+    let before;
+    try {
+      const [{csn}] = await db.read('cds.Model');
+      before = JSON.parse(csn);
+    } catch(e) {
+      if (!e.message.includes('no such table') && !e.message.includes('relation "cds_model" does not exist')) throw e
+      // TODO: Put both into one tx - read can not be part of it, as the transaction gets killed in PG once an error appears
+      await db.run(sqls.create)
+      await db.run(sqls.insert)
+      before = null;
+    }
+    const { afterImage, drops:_drops, createsAndAlters:_creas } = cds.compile.to.sql.delta (csn, {...o, ...db.options}, before)
     creas = _creas.concat (o.dry ? [] : UPDATE('cds.Model').with({ csn: JSON.stringify(afterImage) }))
     drops = before ? _drops : _drops4(_creas)
   } else {
-    creas = cds.compile.to.sql (csn, o)
-    drops = _drops4(creas) .concat ('DROP table if exists cds_Model;')
+    creas = cds.compile.to.sql (csn, {...o, ...db.options})
+    drops = _drops4(creas) .concat (sqls.drop)
   }
   if (!creas || creas.length === 0) return
 
@@ -130,7 +153,7 @@ exports.create = async function cds_deploy_create (db, csn=db.model, o) {
   else return db.run (async tx => {
     // This runs in a new transaction if called from CLI, while joining
     // existing root tx, e.g. when called from DeploymentService.
-    if (!schevo && await tx.exists('sqlite.schema').where({name:'cds_xt_Extensions'})) {
+    if (!schevo && db.kind == 'sqlite' && await tx.exists('sqlite.schema').where({name:'cds_xt_Extensions'})) {
       // Poor man's schema evolution for extensions in drop-create deployments
       drops = drops.filter(d => !d.includes('cds_xt_Extensions'))
       creas = creas.filter(c => !c.includes('cds_xt_Extensions'))
@@ -207,7 +230,8 @@ exports.resources = async function cds_deploy_resources (csn, opts) {
           const f = fx.slice(0,-ext.length)
           if (/[._]texts$/.test(f) && files.some(g => g.startsWith(f+'_'))) {
             // ignores 'Books_texts.csv/json' if there is any 'Books_texts_LANG.csv/json'
-            DEBUG && DEBUG (`ignoring '${fx}' in favor of translated ones`); continue
+            DEBUG && DEBUG (`ignoring '${fx}' in favor of translated ones`)
+            continue
           }
           const e = _entity4(f,csn); if (_skip(e)) continue
           if (cds.env.features.deploy_data_onconflict === 'replace' && !/[._]texts_/.test(f)) {

package/lib/env/cds-env.js

@@ -32,11 +32,7 @@ class Config {
     const { NODE_ENV, CDS_ENV } = process.env, profiles = []
     if (NODE_ENV) profiles.push (NODE_ENV)
     if (CDS_ENV) profiles.push (...CDS_ENV.split(/\s*,\s*/))
-    if (_home) try {
-      const { cds } = require(path.join(_home,'package.json'))
-      if (cds?.profiles) profiles.push(...cds.profiles)
-      if (cds?.profile) profiles.push(cds.profile)
-    } catch {/* ignore */}
+    if (_home) _add_static_profiles (_home, profiles);
     if (!profiles.includes('production')) profiles.push('development')
     this._profiles = new Set (profiles)
     this._profiles._defined = new Set()
@@ -78,17 +74,34 @@ class Config {
     // 6. complete service configurations from cloud service bindings
     this._add_cloud_service_bindings(process.env)
 
-    // 7. Add compatibility for mtx
-    if (this.requires && this.requires.db) {
-      if (this.requires.multitenancy !== undefined) {
-        Object.defineProperty(this.requires.db, 'multiTenant', { value: !!this.requires.multitenancy })
+    // 7. Add compatibility and correlations for mtx, better-sqlite, and lean draft
+    const db  = this.requires?.db
+    if (this.requires?.db) {
+      if (this.requires.multitenancy !== undefined)
+        Object.defineProperty (db, 'multiTenant', { value: !!this.requires.multitenancy })
+      else if (db.multiTenant !== undefined)
+        this.requires.multitenancy = db.multiTenant
+      // Automatically use new sqlite service if in package dependencies
+      const new_sqlite_service = '@cap-js/sqlite'
+      if (db.kind === 'sqlite') try {
+        const pkg = require(path.join(_home,'package.json'))
+        if (pkg.dependencies?.[new_sqlite_service] || pkg.devDependencies?.[new_sqlite_service]) {
+          db.impl = new_sqlite_service
+        }
+      } catch (e) {
+        if (e.code !== 'MODULE_NOT_FOUND') throw e
+      }
+      // Add correlation b/w better-sqlite and lean-draft
+      if (this.fiori && this.fiori.lean_draft === undefined && db.impl === new_sqlite_service) {
+        this.fiori.lean_draft = true
       }
-      else if (this.requires.db.multiTenant !== undefined) this.requires.multitenancy = this.requires.db.multiTenant
     }
 
+
     // 8. apply presets
     presets (this)
 
+
     // Only if feature is enabled
     if (this.features && this.features.emulate_vcap_services) {
       this._emulate_vcap_services()
@@ -124,6 +137,12 @@ class Config {
   add (conf, /*from:*/ _src, profiles = this._profiles, profiles_only = false) {
     if (!conf)  return this
     if (_src)  this._sources.push (_src)
+    const reqs = conf.requires
+    if (reqs) { // normalize requires.x = kind to requires.x = {kind}
+      for (let each in reqs) {
+        if (typeof reqs[each] === 'string') reqs[each] = {kind:conf.requires[each]}
+      }
+    }
     _merge (this, conf, profiles, undefined, profiles_only)
     return this
   }
@@ -278,7 +297,7 @@ class Config {
       if (typeof preset === 'object' && preset !== val) {
         const top = val, base = _merge ({},_linked(p,preset), _profiles), {kind} = base
         val = _merge (base, top, _profiles, false)  // apply/override with top-level data
-        if (kind) val.kind = kind              // but inherited kind wins
+        if (kind) val.kind = kind                  // but inherited kind wins
       }
       if (typeof val === 'object') Object.defineProperty (val, '_is_linked', {value:true})
       return val
@@ -418,13 +437,27 @@ class Config {
 }
 
 
-
-
 //////////////////////////////////////////////////////////////////////////
 //
 //    Local Helpers...
 //
 
+/**
+ * Allows to set profiles in package.json or .cdsrc.json like so:
+ * ```json
+ * { "cds": { "profiles": ["mtx-sidecar","java"] } }
+ * { "cds": { "profile": "mtx-sidecar" } }
+ * ```
+ */
+function _add_static_profiles (_home, profiles) {
+  for (let src of ['package.json', '.cdsrc.json']) try {
+    const conf = require(path.join(_home,src))
+    const cds = src === '.cdsrc.json' ? conf : conf.cds
+    if (cds?.profiles) return profiles.push(...cds.profiles)
+    if (cds?.profile) return profiles.push(cds.profile)
+  } catch (e) { if (e.code !== 'MODULE_NOT_FOUND') throw e }
+}
+
 /**
  * @returns {Config} dst
  */
@@ -442,7 +475,7 @@ function _merge (dst, src, _profiles, _cloned, _profiles_only = false) {
       const profile = p.slice(1,-1)
       if (_profiles._defined)  _profiles._defined.add (profile)
       if (_profiles.has(profile)) {
-        let o = src[p]; if (typeof o === 'string') o = {kind:o}
+        let o = src[p]; if (typeof o !== 'object') continue
         profiled.push ({ profile, merge: () => _merge (dst, o, _profiles, _cloned, false)})
       }
       continue

package/lib/env/cds-requires.js

@@ -120,27 +120,36 @@ const _databases = {
     '[development]': { kind: 'sqlite', credentials: { url: ':memory:' } },
     '[production]': { kind: 'hana' },
   },
+
+  "sqlite": _compat_to_use({
+    '[better-sqlite]': { impl: '@cap-js/sqlite' },
+    impl: `${_runtime}/sqlite/Service.js`,
+    credentials: { url: 'db.sqlite' },
+  }),
+
   "better-sqlite": {
     credentials: { url: ":memory:" },
     impl: "@cap-js/sqlite",
     kind: 'sqlite'
   },
-  "sql-mt": { // For compatibility only
-    '[development]': { kind: 'sqlite' },
-    '[production]': { kind: 'hana-mt' },
-  },
-  "sqlite": _compat_to_use({
-    '[better-sqlite]': { impl: '@cap-js/sqlite' },
+  "legacy-sqlite": _compat_to_use({
     impl: `${_runtime}/sqlite/Service.js`,
     credentials: { url: 'db.sqlite' },
+    kind: 'sqlite'
   }),
+
   "hana": _compat_to_use ({
     impl: `${_runtime}/hana/Service.js`,
   }),
   "hana-cloud": _compat_to_use ({
     kind: 'hana', "deploy-format": "hdbtable",
   }),
-  "hana-mt": _compat_to_use ({
+
+  "sql-mt": { // For compatibility only
+    '[development]': { kind: 'sqlite' },
+    '[production]': { kind: 'hana-mt' },
+  },
+  "hana-mt": _compat_to_use ({ // For compatibility only
     kind: 'hana', "deploy-format": "hdbtable",
     "vcap": {
       "label": "service-manager"

package/lib/env/defaults.js

@@ -31,8 +31,8 @@ const defaults = module.exports = {
   fiori: {
     preview: !production,
     routes: !production,
-    lean_draft: false,
-    draft_compat: false,
+    lean_draft: undefined,
+    draft_compat: undefined,
     '[better-sqlite]': { lean_draft: true },
     '[lean-draft]': { lean_draft: true },
     '[draft-compat]': { draft_compat: true },

package/lib/env/schemas/cds-rc.json

@@ -86,6 +86,7 @@
                   "java",
                   "hana",
                   "mtx-sidecar",
+                  "mtx-extension",
                   "mtx",
                   "fiori",
                   "node-cf",
@@ -611,18 +612,10 @@
           "const": "hana-cloud",
           "description": "SAP HANA Cloud"
         },
-        {
-          "const": "hana-mt",
-          "description": "Multitenant SAP HANA Cloud"
-        },
         {
           "const": "sql",
           "description": "In-memory SQLite (development), SAP HANA (production)"
         },
-        {
-          "const": "sql-mt",
-          "description": "File-based SQLite (development), Multitenant SAP HANA Cloud (production)"
-        },
         {
           "const": "sqlite",
           "description": "File-based SQLite"

package/lib/index.js

@@ -137,7 +137,7 @@ extend (cds.__proto__) .with (lazified ({
 const odp = Object.defineProperty, _global = (_,...pp) => pp.forEach (p => odp(global,p,{
   configurable:true, get:()=>{ let v=cds[_][p]; odp(this,p,{value:v}); return v }
 }))
-_global ('ql','SELECT','INSERT','UPSERT','UPDATE','DELETE','CREATE','DROP')
+_global ('ql','SELECT','INSERT','UPSERT','UPDATE','DELETE','CREATE','DROP','STREAM')
 _global ('parse','CDL','CQL','CXL')
 
 // Check Node.js version

package/lib/ql/STREAM.js

@@ -0,0 +1,89 @@
+const Whereable = require('./Whereable'), { parse } = Whereable
+
+module.exports = class Query extends Whereable {
+
+  static _api() {
+    const $ = Object.assign
+    return $((..._)  => new this()._column_or_data_or_from(..._), {
+      into: (..._)   => new this().into(..._),
+      from: (..._)   => new this().from(..._),
+      column: (..._) => new this().column(..._),
+      columns: (..._) => new this().columns(..._),
+    })
+  }
+
+  _column_or_data_or_from (col, ...more) { // srv.read`title`.from`Books` or srv.read`Books` ?
+    if (!col) return this
+    else if (col.name) return this.from (...arguments) //> clearly a from
+    else if (col.raw) { // tagged template string
+      if (col[0].startsWith('from ')) { // STREAM`from ...`, with an arbitrary long CQL tail...
+        Object.assign (this.STREAM, STREAM_(' ',arguments))
+        return this
+      } else if (col[0][0] === '{') {  // STREAM`{a,b}`... -> it's column
+        let {column:c} = STREAM_('from X', arguments)
+        return this._add('column',c)
+      } else {                          // STREAM`Foo` -> ambiguous -> try parsing as column...
+        let {column:c} = STREAM_('from X {', arguments, '}')
+        if (c.length > 1 || !c[0].ref) return this._add('column',c)
+        // else cols = c[0] //> goes on below...
+      }
+    } else { // STREAM('foo')
+      if (Array.isArray(col)) return this.columns(col)
+      if (typeof col === 'string') return this.column(col)
+      else return this.data(col)
+    }
+
+    // return a proxy assuming it's a from and switching to
+    // column on a subsequent call of .from, if any.
+    const {STREAM:_} = this
+    return Object.defineProperties (this.from (col, ...more), {
+      from: { configurable:true, value:(...args) => { delete this.from
+        return this.from (...args) .column (col, ...more)
+      }}
+    })
+  }
+
+  column (col) {
+    this._add ('column',col)
+    return this
+  }
+
+  columns (cols) {
+    this._add ('columns',cols)
+    return this
+  }
+
+  from (target, key, column) {
+    this.STREAM.from = this._target_ref4 (...arguments)
+    if (!target.raw && key) {
+      this.byKey(key)
+      if (typeof column === 'function') {
+        const cols=[]; column (new Proxy (column,{ get: (_,p) => cols.push(p) }))
+        cols.length === 1 ? this.column(cols[0]) : this.columns(cols)
+      }
+      else if (column) this.column(column)
+    }
+    return this
+  }
+
+  into (target, key) {
+    this.STREAM.into = this._target_ref4 (...arguments)
+    if (!target.raw && key) {
+      this.byKey(key)
+    }
+    return this
+  }
+
+  data (x) {
+    this.STREAM.data = x
+    return this
+  }
+}
+
+
+const {CQL} = parse, STREAM_ = (prefix, [ strings, ...more ], suffix) => {
+  const tts = [...strings]; tts.raw = true
+  if (prefix) tts[0] = `STREAM ${prefix} ${tts[0]}`
+  if (suffix) tts[tts.length-1] += ` ${suffix}`
+  return CQL(tts,...more).STREAM
+}

package/lib/ql/cds-ql.js

@@ -11,13 +11,14 @@ require = path => { // eslint-disable-line no-global-assign
 
 module.exports = {
   Query, clone: (q,_) => Query.prototype.clone.call(q,_),
+  STREAM: require('./STREAM'),
   SELECT: require('./SELECT'),
   INSERT: require('./INSERT'),
   UPSERT: require('./UPSERT'),
   UPDATE: require('./UPDATE'),
   DELETE: require('./DELETE'),
   CREATE: require('./CREATE'),
-  DROP: require('./DROP'),
+  DROP:   require('./DROP'),
 }
 
 module.exports._reset = ()=>{ // for strange tests only

package/lib/req/request.js

@@ -42,6 +42,7 @@ class Request extends require('./event') {
       if (q.UPSERT) return this._set ('path', _path4 (q.UPSERT,'into'))
       if (q.UPDATE) return this._set ('path', _path4 (q.UPDATE,'entity'))
       if (q.DELETE) return this._set ('path', _path4 (q.DELETE,'from'))
+      if (q.STREAM) return this._set ('path', _path4 (q.STREAM,'from') || _path4 (q.STREAM,'into'))
     }
     const {_} = this
     if (_.target) return this._set ('path', _.target.name)
@@ -65,7 +66,8 @@ class Request extends require('./event') {
       q?.INSERT?.into ||
       q?.UPSERT?.into ||
       q?.UPDATE?.entity ||
-      q?.DELETE?.from
+      q?.DELETE?.from ||
+      q?.STREAM?.from || q?.STREAM?.into
     )
 
     const {target} = this; if (!target) return undefined
@@ -113,7 +115,7 @@ class Request extends require('./event') {
 
       // create copy
       const {SELECT:{from:{ref}}} = SELECT.from(id,keys)
-      subjectRef.push(...ref)      
+      subjectRef.push(...ref)
     })
     return super.subject = {ref: subjectRef}
   }
@@ -165,6 +167,7 @@ const Http2Crud = {
 }
 
 const SQL2Crud = {
+  STREAM:   'STREAM',
   SELECT:   'READ',
   INSERT:   'CREATE',
   UPSERT:   'UPSERT',

package/lib/req/user.js

@@ -24,7 +24,7 @@ class User {
       role === 'identified-user' || 
       role === 'system-user' && this._is_system || 
       role === 'internal-user' && this._is_internal || 
-      role === 'authenticated-user' && this.authLevel !== 'weak' || 
+      role === 'authenticated-user' || 
       !!this.roles[role] 
   }
   valueOf() { return this.id }

package/lib/srv/middlewares/index.js

@@ -12,7 +12,7 @@ exports.before = [
   auth,       // provides req.user & tenant
   ctx_auth,   // propagates auth results to cds.context
   ctx_model,  // fills in cds.context.model, in case of extensibility
-].map(_instantiate)
+].map(mw => _instantiate(mw))
 
 // middlewares running after protocol adapters -> usually error middlewares
 exports.after = [
@@ -29,18 +29,20 @@ exports.after = [
  * cds.middlewares.add (mymw) // to the end
  * ```
  */
-exports.add = (new_mw, { at: index, before, after, options }) => {
-  let mw = new_mw (options)
-  if (index)  return exports.before.splice (index, 0, mw)
-  if (before) return exports.before.splice (index, _index4(before), mw)
-  if (after)  return exports.before.splice (index, _index4(after)+1, mw)
+exports.add = (new_mw, { at: index, before, after, options } = {}) => {
+  let mw = _isNotWrapped(new_mw) ? new_mw : new_mw (options)
+  if (index !== undefined) return exports.before.splice (index, 0, mw)
+  if (before) return exports.before.splice (_index4(before), 0, mw)
+  if (after)  return exports.before.splice (_index4(after)+1, 0, mw)
   else return exports.before.push(mw)
 }
 
+const _isNotWrapped = mw => (typeof mw === 'function' && mw.length === 3) || Array.isArray(mw)
+
 function _index4 (middleware) {
   if (typeof middleware === 'string') middleware = exports[middleware]
   if (!middleware) throw new Error (`Didn't find a middleware matching ${{middleware}}`)
-  const index = exports.before.findIndex(mw => mw.factory === before)
+  const index = exports.before.findIndex(mw => mw.factory === middleware)
   if (index === -1) throw new Error (`Didn't find ${{middleware}} in cds.middlewares.before`)
   return index
 }

package/lib/srv/middlewares/trace.js

@@ -61,11 +61,12 @@ function _instrument_cds_services (_get_perf) {
   }
 }
 
+let sqlite
 function _instrument_sqlite (_get_perf) {
   const me = _instrument_sqlite; if (me.done) return; else me.done = true
   try { require.resolve('sqlite3') } catch { return }
   // eslint-disable-next-line cds/no-missing-dependencies
-  const sqlite = require('sqlite3').Database.prototype
+  sqlite = require('sqlite3').Database.prototype
   for (let each of ['all', 'get', 'run', 'prepare']) _wrap(each,sqlite)
   function _wrap (op,sqlite) {
     const _super = sqlite[op]
@@ -73,11 +74,11 @@ function _instrument_sqlite (_get_perf) {
       const perf = _get_perf(q) //> q is a SQL command like BEGIN, COMMIT, ROLLBACK, SELECT ...
       if (perf) {
         const pe = perf.log ('sqlite3', '-', q)
-        const callback = _[_.length-1]; _[_.length-1] = function(ps){
+        const callback = _[_.length-1]; _[_.length-1] = function(){
           if (op === 'prepare') callback.apply (this, {
-            all: _wrap('all',ps),
-            get: _wrap('get',ps),
-            run: _wrap('run',ps),
+            all: _wrap('all',sqlite),
+            get: _wrap('get',sqlite),
+            run: _wrap('run',sqlite),
           }); else {
             perf.done(pe)
             callback.apply (this, arguments)

package/lib/srv/srv-api.js

@@ -71,6 +71,7 @@ class Service extends require('./srv-handlers') {
     return this.dispatch (req)
   }
   read   (...args) { return is_query(args[0]) ? this.run(...args) : SELECT(...args).bind(this) }
+  stream (...args) { return is_query(args[0]) ? this.run(...args) : STREAM(...args).bind(this) }
   insert (...args) { return INSERT(...args).bind(this) }
   create (...args) { return INSERT.into(...args).bind(this) }
   update (...args) { return UPDATE.entity(...args).bind(this) }

package/lib/utils/cds-utils.js

@@ -194,7 +194,7 @@ exports._oldMtx = function _oldMtx() {
  * Internal utility to load a file through ESM or CommonJs.  TODO find a better place.
  */
 exports._import = id => require(id)
-if (typeof jest === 'undefined') {  // jest's ESM support is experimental: https://jestjs.io/docs/ecmascript-modules
+if (process.env.JEST_WORKER_ID === undefined) {  // jest's ESM support is experimental: https://jestjs.io/docs/ecmascript-modules
   const { pathToFileURL } = require('url')
   exports._import = id => {
     if (extname(id) === '.ts') return require(id) // ts-node w/ ESM not working (cap/issues#11980)

package/lib/utils/tar.js

@@ -83,7 +83,7 @@ exports.create = async (dir='.', ...args) => {
   let c, temp
   args = args.filter(el => el)
   if (process.platform === 'win32') {
-    const spawnDir = (dir, args) => {      
+    const spawnDir = (dir, args) => {
       if (args.some(arg => arg === '-f')) return spawn ('tar', ['c', '-C', win(dir), ...win(args)])
       else return spawn ('tar', ['cf', '-', '-C', win(dir), ...win(args)])
     }
@@ -101,7 +101,7 @@ exports.create = async (dir='.', ...args) => {
     } else {
       args.push('.')
     }
-  
+
     c = spawn ('tar', ['c', '-C', dir, ...args])
   }
 
@@ -112,21 +112,15 @@ exports.create = async (dir='.', ...args) => {
      * in-memory Buffer holding the tar output, hence enabling this usage:
      * @example const buffer = await tar.c('src/dir')
      */
-    then (r,e) {
-      const bb=[]
-      const eb=[]
-      c.stdout.on('data', b => bb.push(b))
-      c.stderr.on('data', b => eb.push(b))
-      c.on('close', (code) => {
-        if (code === 0) {
-          return r(Buffer.concat(bb))
-        }
-        e(new Error('tar: ' + Buffer.concat(eb)))
-      })
-      c.on('error', e)
+    then (resolve, reject) {
+      let data=[], stderr=''
+      c.stdout.on('data', d => data.push(d))
+      c.stderr.on('data', d => stderr += d)
+      c.on('close', code => code ? reject(new Error(stderr)) : resolve(Buffer.concat(data)))
+      c.on('error', reject)
       if (process.platform === 'win32') {
-        c.on('close', async () => temp && exists(temp) && await rimraf(temp))
-        c.on('error', async () => temp && exists(temp) && await rimraf(temp))
+        c.on('close', () => temp && exists(temp) && rimraf(temp))
+        c.on('error', () => temp && exists(temp) && rimraf(temp))
       }
     },
 
@@ -143,9 +137,9 @@ exports.create = async (dir='.', ...args) => {
       }
       // Returning a thenable ChildProcess.stdout
       return {__proto__: c.stdout.pipe (out),
-        then(r,e) {
-          out.on('close',r)
-          c.on('error',e)
+        then (resolve, reject) {
+          out.on('close', code => code ? reject(code) : resolve())
+          c.on('error', reject)
         }
       }
     }
@@ -175,18 +169,21 @@ exports.extract = (archive, ...args) => ({
   to (...dest) {
     if (typeof dest === 'string') dest = _resolve(...dest)
     const input = typeof archive !== 'string' || archive == '-' ? '-' : _resolve(archive)
-    const x = spawn('tar', ['xf', win(input), '-C', win(dest), ...args])
+    const x = spawn('tar', ['xf', win(input), '-C', win(dest), ...args], { env: { COPYFILE_DISABLE: 1 }})
     if (archive === '-') return x.stdin
     if (Buffer.isBuffer(archive)) archive = require('stream').Readable.from (archive)
     if (typeof archive !== 'string') archive.pipe (x.stdin)
-    if (args.includes('-v')) {
-      var list = '';
-      ;(process.platform === 'linux' ? x.stdout : x.stderr) .on ('data', d => list+=d)
-    }
+    let stdout='', stderr=''
+    x.stdout.on ('data', d => stdout += d)
+    x.stderr.on ('data', d => stderr += d)
     return {__proto__:x,
-      then(r,e) {
-        x.on('close',()=>r(list ? list.split('\n').slice(0,-1).map(x => x.replace(/^x |\r/g,'')) : undefined))
-        x.on('error',e)
+      then (resolve, reject) {
+        x.on('close', code => {
+          if (code) return reject (new Error(stderr))
+          if (process.platform === 'linux') stdout = stderr
+          resolve (stdout ? stdout.split('\n').slice(0,-1).map(x => x.replace(/^x |\r/g,'')): undefined)
+        })
+        x.on('error', reject)
       }
     }
   },
@@ -205,11 +202,13 @@ exports.extract = (archive, ...args) => ({
 exports.list = (archive, ...more) => {
   const input = typeof archive !== 'string' ? '-' : archive === '-' ? archive : _resolve(archive)
   const x = spawn(`tar tf`, [ input, ...more ], { shell:true })
-  let list = ''; x.stdout.on ('data', d => list+=d)
+  let stdout='', stderr=''
+  x.stdout.on ('data', d => stdout += d)
+  x.stderr.on ('data', d => stderr += d)
   return {__proto__:x,
-    then(r,e) {
-      x.on('close',()=>r(list.split('\n').slice(0,-1)))
-      x.on('error',e)
+    then (resolve, reject) {
+      x.on('close', code => code ? reject(new Error(stderr)) : resolve(stdout.split('\n').slice(0,-1)))
+      x.on('error', reject)
     }
   }
 }