@sap/cds 6.0.3 → 6.1.1

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

@@ -1,42 +1,47 @@
 const cds = require('../index'), { cds_tx_protection } = cds.env.features
 const EventContext = require('../req/context')
-class RootContext extends EventContext {}
+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(_)
+  }
+}
+
 
 /**
  * This is the implementation of the `srv.tx(req)` method. It constructs
  * a new Transaction as a derivate of the `srv` (i.e. {__proto__:srv})
- * @returns { Transaction & import('./Service-api') }
+ * @returns { Transaction & import('./srv-api') }
  * @param { EventContext } ctx
  */
-module.exports = function tx (ctx,fn) { const srv = this
+function srv_tx (ctx,fn) { const srv = this
 
   if (srv.context) return srv // srv.tx().tx() -> idempotent
+  if (!ctx) return RootTransaction.for (srv)
+
+  // Creating root or nested txes for existing contexts
+  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 = 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)
-  }
-
-  if (ctx) {
-    if (ctx.context) ctx = ctx.context
-
-    // 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: ctx = RootContext.for(ctx) })
-    return RootTransaction.for (srv, ctx)
+    const tx = RootTransaction.for (srv, ctx)
+    return cds._context.run (tx, ()=> Promise.resolve(fn(tx)) .then (tx.commit, tx.rollback))
   }
 
-  // `ctx` is a plain context object or undefined
-  return RootTransaction.for (srv, 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)
 }
 
 
@@ -45,19 +50,23 @@ class Transaction {
   /**
    * Returns an already started tx for given srv, or creates a new instance
    */
-  static for (srv,root) {
-    let txs = root.transactions
-    if (!txs) Object.defineProperty(root, 'transactions', {value: txs = new Map})
+  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,root))
+    if (!tx) txs.set (srv, tx = new this (srv,ctx))
     return tx
   }
 
-  constructor (srv,root) {
-    const tx = { __proto__:srv, context:root }
+  constructor (srv, ctx) {
+    const tx = { __proto__:srv, _kind: new.target.name, context: ctx }
     const proto = new.target.prototype
     tx.commit   = proto.commit.bind(tx)
     tx.rollback = proto.rollback.bind(tx)
+    if (srv.isExtensible) {
+      const m = cds.context?.model
+      if (m) tx.model = m
+    }
     return _init(tx)
   }
 
@@ -102,11 +111,12 @@ class Transaction {
 class RootTransaction extends Transaction {
 
   /**
-   * Register the new transaction with the root context.
-   * @param {EventContext} root
+   * Register the new transaction with the given context.
+   * @param {EventContext} ctx
    */
-  static for (srv,root) {
-    return root.tx = super.for (srv,root)
+  static for (srv, ctx) {
+    ctx = RootContext.for (ctx?.tx?._done ? {} : ctx)
+    return ctx.tx = super.for (srv, ctx)
   }
 
   /**
@@ -148,16 +158,21 @@ class RootTransaction extends Transaction {
 
 class NestedTransaction extends Transaction {
 
+  static for (srv,ctx) {
+    ctx = NestedContext.for (ctx)
+    return super.for (srv, ctx)
+  }
+
   /**
-   * Registers event listeners with the root context, to commit or rollback
+   * Registers event listeners with the given context, to commit or rollback
    * when the root tx is about to commit or rollback.
-   * @param {import ('../req/context')} root
+   * @param {EventContext} ctx
    */
-  constructor (srv,root) {
-    super (srv,root)
-    root.before ('succeeded', ()=> this.commit())
-    root.before ('failed', ()=> this.rollback())
-    if ('end' in srv) root.once ('done', ()=> srv.end())
+  constructor (srv,ctx) {
+    super (srv,ctx)
+    ctx.before ('succeeded', ()=> this.commit())
+    ctx.before ('failed', ()=> this.rollback())
+    if ('end' in srv) ctx.once ('done', ()=> srv.end())
   }
 
 }
@@ -188,3 +203,5 @@ const _begin = async function (req) {
   delete this.dispatch
   return this.dispatch (req)
 }
+
+module.exports = srv_tx

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

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

package/lib/utils/cds-utils.js

@@ -0,0 +1,146 @@
+const cwd = process.env._original_cwd || process.cwd()
+const path = require ('path'), { dirname, extname, join, resolve, relative } = path
+const fs = require('fs')
+const cds = require('../index')
+
+const all = module.exports = exports = { ...fs,
+  get inspect() { return $set (this, 'inspect', require('util').inspect) },
+  get uuid() { return $set (this, 'uuid', require('@sap/cds-foss').uuid) },
+}
+
+exports.fs = all
+exports.path = path
+
+exports.local = (file) => relative(cwd,file)
+
+exports.readdir = async function (x) {
+  const d = resolve (cds.root,x)
+  return fs.promises.readdir(d)
+}
+
+exports.stat = async function (x) {
+  const d = resolve (cds.root,x)
+  return fs.promises.stat(d)
+}
+
+exports.exists = function exists (x) {
+  if (x) {
+    const y = resolve (cds.root,x)
+    return fs.existsSync(y)
+  }
+}
+
+exports.isdir = function isdir (x) {
+  if (x) try {
+    const y = resolve (cds.root,x)
+    const ls = fs.lstatSync(y)
+    if (ls.isDirectory()) return y
+    if (ls.isSymbolicLink()) return isdir (join (dirname(y), fs.readlinkSync(y)))
+  } catch(e){/* ignore */}
+}
+
+exports.isfile = function isfile (x) {
+  if (x) try {
+    const y = resolve (cds.root,x)
+    const ls = fs.lstatSync(y)
+    if (ls.isFile()) return y
+    if (ls.isSymbolicLink()) return isfile (join (dirname(y), fs.readlinkSync(y)))
+  } catch(e){/* ignore */}
+}
+
+exports.read = async function read (file, _encoding) {
+  const f = resolve (cds.root,file)
+  const src = await fs.promises.readFile (f, _encoding !== 'json' && _encoding || 'utf8')
+  return _encoding === 'json' || !_encoding && f.endsWith('.json') ? JSON.parse(src) : src
+}
+
+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))
+  const f = resolve (cds.root,file)
+  return mkdirp (dirname(f)).then (()=> fs.promises.writeFile (f,data,o))
+}
+
+exports.mkdirp = async function (...path) {
+  const d = resolve (cds.root,...path)
+  await fs.promises.mkdir (d,{recursive:true})
+  return d
+}
+
+exports.rmdir = (...path) => {
+  const d = resolve (cds.root,...path)
+  return fs.promises.rm (d, {recursive:true})
+}
+
+exports.rimraf = (...path) => {
+  const d = resolve (cds.root,...path)
+  return fs.promises.rm (d, {recursive:true,force:true})
+}
+
+exports.rm = async function rm (x) {
+  const y = resolve (cds.root,x)
+  return fs.promises.rm(y)
+}
+
+exports.copy = async function copy (x,y) {
+  const src = resolve (cds.root,x)
+  const dst = resolve (cds.root,y)
+  if (fs.promises.cp) return fs.promises.cp (src,dst,{recursive:true})
+  await mkdirp (dirname(dst))
+  if (isdir(src)) {
+    const entries = await fs.promises.readdir(src)
+    return Promise.all (entries.map (async each => {
+      const e = join (src,each)
+      const f = join (dst,each)
+      return copy (e,f)
+    }))
+  } else {
+    return fs.promises.copyFile (src,dst)
+  }
+}
+
+exports.find = function find (base, patterns='*', filter=()=>true) {
+  const files=[];  base = resolve (cds.root,base)
+  if (typeof patterns === 'string')  patterns = patterns.split(',')
+  if (typeof filter === 'string')  filter = this[filter]
+  patterns.forEach (pattern => {
+    const star = pattern.indexOf('*')
+    if (star >= 0) {
+      const head = pattern.slice(0,star).replace(/[^/\\]*$/,'')
+      const dir = join (base,head)
+      try {
+        const ls = fs.lstatSync(dir)
+        if (ls.isDirectory()) {
+          const [,suffix,tail] = /([^/\\]*)?(?:.(.*))?/.exec (pattern.slice(star+1))
+          const prefix = pattern.slice(head.length,star)
+          let entries = fs.readdirSync(dir) //.filter (_filter)
+          if (prefix)  entries = entries.filter (e => e.startsWith(prefix));  if (!entries.length) return
+          if (suffix)  entries = entries.filter (e => e.endsWith(suffix));  if (!entries.length) return
+          let paths = entries.map (e=>join(dir,e))
+          if (filter)  paths = paths.filter (filter);  if (!paths.length) return
+          if (tail)  for (let _files of paths.map (e=>find (e,tail,filter)))  files.push (..._files)
+          else  files.push (...paths)
+        }
+      } catch(e) {/* ignore */}
+    } else {
+      const file = join (base, pattern)
+      if (fs.existsSync(file))  files.push (file)
+    }
+  })
+  return files
+}
+
+
+// internal utility to load a file through ESM or CommonJs.  TODO find a better place.
+const { pathToFileURL } = require('url')
+exports._import = async function(filePath) {
+  return typeof jest !== 'undefined' || extname(filePath) === '.ts' // ts-node w/ ESM not working (cap/issues#11980)
+    ? require(filePath)
+    : import (pathToFileURL(filePath).href) // must use a file: URL, esp. on Windows for C:\... paths
+}
+
+
+/** @type <T>(o,p,v:T) => T */
+const $set = (o,p,v) => { Object.defineProperty(o,p,{value:v}); return v }
+const { mkdirp, isdir } = exports

package/lib/utils/index.js

@@ -1,145 +1,2 @@
-const cwd = process.env._original_cwd || process.cwd()
-const path = require ('path'), { dirname, extname, join, resolve, sep, relative } = path
-const fs = require('fs')
-const cds = require('../index')
-
-const all = module.exports = exports = { ...fs,
-  get inspect() { return $set (this, 'inspect', require('util').inspect) },
-  get uuid() { return $set (this, 'uuid', require('@sap/cds-foss').uuid) },
-}
-
-exports.fs = all
-exports.path = path
-
-exports.local = (file) => relative(cwd,file)
-
-exports.readdir = async function (x) {
-  const d = resolve (cds.root,x)
-  return fs.promises.readdir(d)
-}
-
-exports.stat = async function (x) {
-  const d = resolve (cds.root,x)
-  return fs.promises.stat(d)
-}
-
-exports.exists = function exists (x) {
-  if (x) {
-    const y = resolve (cds.root,x)
-    return fs.existsSync(y)
-  }
-}
-
-exports.isdir = function isdir (x) {
-  if (x) try {
-    const y = resolve (cds.root,x)
-    const ls = fs.lstatSync(y)
-    if (ls.isDirectory()) return y
-    if (ls.isSymbolicLink()) return isdir (join (dirname(y), fs.readlinkSync(y)))
-  } catch(e){/* ignore */}
-}
-
-exports.isfile = function isfile (x) {
-  if (x) try {
-    const y = resolve (cds.root,x)
-    const ls = fs.lstatSync(y)
-    if (ls.isFile()) return y
-    if (ls.isSymbolicLink()) return isfile (join (dirname(y), fs.readlinkSync(y)))
-  } catch(e){/* ignore */}
-}
-
-exports.read = async function read (file, _encoding) {
-  const f = resolve (cds.root,file)
-  const src = await fs.promises.readFile (f, _encoding !== 'json' && _encoding || 'utf8')
-  return _encoding === 'json' || !_encoding && f.endsWith('.json') ? JSON.parse(src) : src
-}
-
-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))
-  const f = resolve (cds.root,file)
-  return mkdirp (dirname(f)).then (()=> fs.promises.writeFile (f,data,o))
-}
-
-exports.mkdirp = async function (...path) {
-  const d = resolve (cds.root,...path)
-  await fs.promises.mkdir (d,{recursive:true})
-  return d
-}
-
-exports.rmdir = (...path) => {
-  const d = resolve (cds.root,...path)
-  return (fs.promises.rm || fs.promises.rmdir) (d, {recursive:true})
-}
-
-exports.rimraf = (...path) => {
-  const d = resolve (cds.root,...path)
-  return (fs.promises.rm || fs.promises.rmdir) (d, {recursive:true,force:true})
-}
-
-exports.rm = async function rm (x) {
-  const y = resolve (cds.root,x)
-  return (fs.promises.rm || fs.promises.unlink)(y)
-}
-
-exports.copy = async function copy (x,y) {
-  const src = resolve (cds.root,x)
-  const dst = resolve (cds.root,y)
-  if (fs.promises.cp) return fs.promises.cp (src,dst,{recursive:true})
-  await mkdirp (dirname(dst))
-  if (isdir(src)) {
-    const entries = await fs.promises.readdir(src)
-    return Promise.all (entries.map (async each => {
-      const e = join (src,each)
-      const f = join (dst,each)
-      return copy (e,f)
-    }))
-  } else {
-    return fs.promises.copyFile (src,dst)
-  }
-}
-
-exports.find = function find (base, patterns='*', filter=()=>true) {
-  const files=[];  base = resolve (cds.root,base)
-  if (typeof patterns === 'string')  patterns = patterns.split(',')
-  if (typeof filter === 'string')  filter = this[filter]
-  patterns.forEach (pattern => {
-    const star = pattern.indexOf('*')
-    if (star >= 0) {
-      const head = pattern.slice(0,star).replace(/[^/\\]*$/,'')
-      const dir = join (base,head)
-      try {
-        const ls = fs.lstatSync(dir)
-        if (ls.isDirectory()) {
-          const [,suffix,tail] = /([^/\\]*)?(?:.(.*))?/.exec (pattern.slice(star+1))
-          const prefix = pattern.slice(head.length,star)
-          let entries = fs.readdirSync(dir) //.filter (_filter)
-          if (prefix)  entries = entries.filter (e => e.startsWith(prefix));  if (!entries.length) return
-          if (suffix)  entries = entries.filter (e => e.endsWith(suffix));  if (!entries.length) return
-          let paths = entries.map (e=>join(dir,e))
-          if (filter)  paths = paths.filter (filter);  if (!paths.length) return
-          if (tail)  for (let _files of paths.map (e=>find (e,tail,filter)))  files.push (..._files)
-          else  files.push (...paths)
-        }
-      } catch(e) {/* ignore */}
-    } else {
-      const file = join (base, pattern)
-      if (fs.existsSync(file))  files.push (file)
-    }
-  })
-  return files
-}
-
-// internal utility to load a file through ESM or CommonJs.  TODO find a better place.
-const { pathToFileURL } = require('url')
-exports._import = async function(filePath) {
-  return typeof jest !== 'undefined' || extname(filePath) === '.ts' // ts-node w/ ESM not working (cap/issues#11980)
-    ? require(filePath)
-    : import (pathToFileURL(filePath).href) // on Windows, must use a file: URL for ESM import
-}
-
-
-/** @type <T>(o,p,v:T) => T */
-const $set = (o,p,v) => { Object.defineProperty(o,p,{value:v}); return v }
-const { mkdirp, isdir } = exports
+// for compatibility with old releases of cds-lint
+module.exports = require('./cds-utils')

package/lib/utils/jest.js

@@ -0,0 +1,43 @@
+let vm = require('vm')
+if (!vm.__caching__) {
+  vm.__caching__ = true
+  const scriptCache = {}
+  vm._Script = vm._Script || vm.Script
+  class CachedScript extends vm._Script {
+    constructor(src, options) {
+      const cached = scriptCache[options.filename]
+      if (cached) {
+        return cached
+      }
+      super(src, options)
+      // Assume that .test.js files are only loaded once
+      if (!options.filename.endsWith('.test.js')) {
+        scriptCache[options.filename] = this
+      }
+    }
+  }
+
+  vm.Script = CachedScript
+}
+vm = undefined
+
+let asyncHooks = require('async_hooks')
+if (!asyncHooks._AsyncLocalStorage) {
+  asyncHooks._AsyncLocalStorage = asyncHooks.AsyncLocalStorage
+  class TmpAsyncLocalStorage extends asyncHooks._AsyncLocalStorage {
+    disable() {
+      if (this._timer) clearTimeout(this._timer)
+      return super.disable()
+    }
+
+    _enable() {
+      if (this._timer) clearTimeout(this._timer)
+      this._timer = setTimeout(() => this.disable(), 60 * 1000)
+      this._timer.unref()
+      return super._enable()
+    }
+  }
+
+  asyncHooks.AsyncLocalStorage = TmpAsyncLocalStorage
+}
+asyncHooks = null

package/lib/utils/resources/index.js

@@ -1,54 +1,44 @@
 const fs = require('fs')
 const path = require('path')
 
-const cds = require('../../../libx/_runtime/cds')
-const { packArchive, packArchiveCLI, unpackArchive, unpackArchiveCLI } = require('./tar')
+const { packArchiveCLI, unpackArchiveCLI } = require('./tar')
 const { exists } = require('./utils')
 
-// use tar command line interface
 const TEMP_DIR = fs.realpathSync(require('os').tmpdir())
 
-const packTarArchive = async (files, root, flat = false, cli = true) => {
-  let tgzBuffer, temp
+const packTarArchive = async (files, root, flat = false) => {
+  if (typeof files === 'string') return await packArchiveCLI(files)
 
+  let tgzBuffer, temp
   try {
     temp = await fs.promises.mkdtemp(`${TEMP_DIR}${path.sep}tar-`)
-    if (flat) {
-      const files_ = []
-      for (const file of files) {
-        const destination = path.join(temp, path.basename(file))
-        await fs.promises.copyFile(file, destination)
-        files_.push(destination)
-      }
-      files = files_
-      root = temp
+    for (const file of files) {
+      const fname = flat ? path.basename(file) : path.relative(root, file)
+      const destination = path.join(temp, fname)
+      const dirname = path.dirname(destination)
+      if (!await exists(dirname)) await fs.promises.mkdir(dirname, { recursive: true })
+      await fs.promises.copyFile(file, destination)
     }
 
-    const relativeFiles = files.map(file => path.relative(root, file))
-    if (cli) {
-      const output = path.relative(root, path.join(temp, `${cds.utils.uuid()}.tgz`))
-      tgzBuffer = await packArchiveCLI(relativeFiles, root, output)
-    } else {
-      tgzBuffer = await packArchive(relativeFiles, root)
-    }
+    tgzBuffer = await packArchiveCLI(temp)
   } finally {
     if (await exists(temp)) {
-      await (fs.promises.rm || fs.promises.rmdir)(temp, { recursive: true, force: true })
+      await fs.promises.rm(temp, { recursive: true, force: true })
     }
   }
 
   return tgzBuffer
 }
 
-const unpackTarArchive = async (buffer, folder, cli = true) => {
+const unpackTarArchive = async (buffer, folder) => {
   const temp = await fs.promises.mkdtemp(`${TEMP_DIR}${path.sep}tar-`)
   const tgz = path.join(temp, 'resources.tgz')
   await fs.promises.writeFile(tgz, Buffer.from(buffer), 'binary')
 
   try {
-    cli ? await unpackArchiveCLI(tgz, folder) : await unpackArchive(tgz, folder)
+    await unpackArchiveCLI(tgz, folder)
   } finally {
-    if (await exists(temp)) await (fs.promises.rm || fs.promises.rmdir)(temp, { recursive: true, force: true })
+    if (await exists(temp)) await fs.promises.rm(temp, { recursive: true, force: true })
   }
 }
 

package/lib/utils/resources/tar.js

@@ -1,21 +1,13 @@
 const fs = require('fs')
 const path = require('path')
 const exec = require('child_process').exec
+const cds = require('../../../libx/_runtime/cds')
+const { exists } = require('./utils')
 
-const _createArchive = (files, root) => {
-  const tar = require('tar')
-  return tar.c(
-    {
-      gzip: true,
-      preservePaths: false,
-      cwd: root
-    },
-    files
-  )
-}
+const TEMP_DIR = fs.realpathSync(require('os').tmpdir())
 
-const _createArchiveCLI = (files, root, output) => {
-  const cmd = 'cd ' + root + ' && tar -czf ' + output + ' ' + files.join(' ')
+const _createArchiveCLI = (root, output) => {
+  const cmd = 'tar -zcvf ' + output + ' -C ' + root + '  .'
 
   return new Promise((resolve, reject) => {
     exec(cmd, err => {
@@ -25,32 +17,19 @@ const _createArchiveCLI = (files, root, output) => {
   })
 }
 
-const packArchive = (files, root) => {
-  _createArchive(files, root)
-  const stream = _createArchive(files, root)
-  return new Promise((resolve, reject) => {
-    const chunks = []
-    stream.on('data', data => chunks.push(data))
-    stream.on('error', error => reject(error))
-    stream.on('end', () => {
-      resolve(Buffer.concat(chunks))
-    })
-  })
-}
-
-const packArchiveCLI = async (files, root, output) => {
-  await _createArchiveCLI(files, root, output)
-
-  return fs.promises.readFile(path.join(root, output))
-}
-
-const unpackArchive = async (tgz, folder) => {
-  const tar = require('tar')
-  await tar.x({
-    file: tgz,
-    gzip: true,
-    C: folder
-  })
+const packArchiveCLI = async (root) => {
+  const temp = await fs.promises.mkdtemp(`${TEMP_DIR}${path.sep}tar-`)
+  const output = path.join(temp, `${cds.utils.uuid()}.tgz`)
+  try {
+    await _createArchiveCLI(root, output)
+
+    return fs.promises.readFile(output)
+  }
+  finally {
+    if (await exists(temp)) {
+      await fs.promises.rm(temp, { recursive: true, force: true })
+    }
+  }
 }
 
 const unpackArchiveCLI = async (tgz, folder) => {
@@ -65,8 +44,6 @@ const unpackArchiveCLI = async (tgz, folder) => {
 }
 
 module.exports = {
-  packArchive,
   packArchiveCLI,
-  unpackArchive,
   unpackArchiveCLI
 }