@zuplo/cli 7.0.2 → 7.1.1

package/node_modules/thread-stream/test/flush-worker.js

@@ -0,0 +1,68 @@
+'use strict'
+
+const { EventEmitter } = require('events')
+const { parentPort } = require('worker_threads')
+
+function createDestination (mode) {
+  const destination = new EventEmitter()
+  destination.writableEnded = false
+  destination.writableNeedDrain = false
+
+  destination.write = function () {
+    if (mode === 'drain') {
+      destination.writableNeedDrain = true
+      setTimeout(() => {
+        destination.writableNeedDrain = false
+        parentPort.postMessage({
+          code: 'EVENT',
+          name: 'destination-drain'
+        })
+        destination.emit('drain')
+      }, 50)
+    }
+
+    return true
+  }
+
+  destination.end = function () {
+    destination.writableEnded = true
+    destination.emit('close')
+  }
+
+  if (mode === 'flush') {
+    destination.flush = function (cb) {
+      setTimeout(() => {
+        parentPort.postMessage({
+          code: 'EVENT',
+          name: 'destination-flushed'
+        })
+        cb()
+      }, 50)
+    }
+  }
+
+  if (mode === 'flush-sync') {
+    destination.flushSync = function () {
+      parentPort.postMessage({
+        code: 'EVENT',
+        name: 'destination-flush-sync'
+      })
+    }
+  }
+
+  if (mode === 'exit-on-flush') {
+    destination.flush = function (_cb) {
+      setTimeout(() => {
+        process.exit(0)
+      }, 20)
+    }
+  }
+
+  return destination
+}
+
+async function run (opts) {
+  return createDestination(opts.mode)
+}
+
+module.exports = run

package/node_modules/thread-stream/test/flush.test.js

@@ -0,0 +1,112 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const { once } = require('node:events')
+const { join } = require('node:path')
+const ThreadStream = require('..')
+
+function createStream (mode) {
+  return new ThreadStream({
+    filename: join(__dirname, 'flush-worker.js'),
+    workerData: { mode },
+    sync: false
+  })
+}
+
+test('flush waits for worker destination.flush(cb)', async function () {
+  const stream = createStream('flush')
+  let flushed = false
+
+  stream.on('destination-flushed', () => {
+    flushed = true
+  })
+
+  assert.ok(stream.write('hello'))
+
+  await new Promise((resolve, reject) => {
+    stream.flush((err) => {
+      if (err) {
+        reject(err)
+        return
+      }
+      resolve()
+    })
+  })
+
+  assert.strictEqual(flushed, true)
+
+  const close = once(stream, 'close')
+  stream.end()
+  await close
+})
+
+test('flush falls back to destination.flushSync()', async function () {
+  const stream = createStream('flush-sync')
+  let called = false
+
+  stream.on('destination-flush-sync', () => {
+    called = true
+  })
+
+  assert.ok(stream.write('hello'))
+
+  await new Promise((resolve, reject) => {
+    stream.flush((err) => {
+      if (err) {
+        reject(err)
+        return
+      }
+      resolve()
+    })
+  })
+
+  assert.strictEqual(called, true)
+
+  const close = once(stream, 'close')
+  stream.end()
+  await close
+})
+
+test('flush waits for drain when destination has no flush API', async function () {
+  const stream = createStream('drain')
+  let drained = false
+
+  stream.on('destination-drain', () => {
+    drained = true
+  })
+
+  assert.ok(stream.write('hello'))
+
+  await new Promise((resolve, reject) => {
+    stream.flush((err) => {
+      if (err) {
+        reject(err)
+        return
+      }
+      resolve()
+    })
+  })
+
+  assert.strictEqual(drained, true)
+
+  const close = once(stream, 'close')
+  stream.end()
+  await close
+})
+
+test('pending flush callbacks fail when worker exits', async function () {
+  const stream = createStream('exit-on-flush')
+  const close = once(stream, 'close')
+
+  assert.ok(stream.write('hello'))
+
+  const err = await new Promise((resolve) => {
+    stream.flush(resolve)
+  })
+
+  assert.ok(err)
+  assert.strictEqual(err.message, 'the worker has exited')
+
+  await close
+})

package/node_modules/thread-stream/test/helper.js

@@ -3,7 +3,6 @@
 const { join } = require('path')
 const { tmpdir } = require('os')
 const { unlinkSync } = require('fs')
-const t = require('tap')
 
 const files = []
 let count = 0
@@ -15,21 +14,13 @@ function file () {
 }
 
 process.on('beforeExit', () => {
-  t.comment('unlink files')
   for (const file of files) {
     try {
-      t.comment(`unliking ${file}`)
       unlinkSync(file)
     } catch (e) {
-      console.log(e)
+      // ignore cleanup errors
     }
   }
-  t.comment('unlink completed')
 })
 
 module.exports.file = file
-
-if (process.env.SKIP_PROCESS_EXIT_CHECK !== 'true') {
-  const why = require('why-is-node-running')
-  setInterval(why, 10000).unref()
-}

package/node_modules/thread-stream/test/indexes.test.js

@@ -1,11 +1,11 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
+const assert = require('node:assert')
 const indexes = require('../lib/indexes')
 
 for (const index of Object.keys(indexes)) {
-  test(`${index} is lock free`, function (t) {
-    t.equal(Atomics.isLockFree(indexes[index]), true)
-    t.end()
+  test(`${index} is lock free`, function () {
+    assert.strictEqual(Atomics.isLockFree(indexes[index]), true)
   })
 }

package/node_modules/thread-stream/test/multibyte-chars.test.mjs

@@ -1,11 +1,11 @@
-import { test } from 'tap'
+import { test } from 'node:test'
+import assert from 'node:assert'
 import { readFile } from 'fs'
 import ThreadStream from '../index.js'
 import { join } from 'desm'
 import { file } from './helper.js'
 
-test('break up utf8 multibyte (sync)', (t) => {
-  t.plan(2)
+test('break up utf8 multibyte (sync)', (t, done) => {
   const longString = '\u03A3'.repeat(16)
 
   const dest = file()
@@ -18,8 +18,9 @@ test('break up utf8 multibyte (sync)', (t) => {
 
   stream.on('finish', () => {
     readFile(dest, 'utf8', (err, data) => {
-      t.error(err)
-      t.equal(data, longString)
+      assert.ifError(err)
+      assert.strictEqual(data, longString)
+      done()
     })
   })
 
@@ -27,8 +28,7 @@ test('break up utf8 multibyte (sync)', (t) => {
   stream.end()
 })
 
-test('break up utf8 multibyte (async)', (t) => {
-  t.plan(2)
+test('break up utf8 multibyte (async)', (t, done) => {
   const longString = '\u03A3'.repeat(16)
 
   const dest = file()
@@ -41,8 +41,9 @@ test('break up utf8 multibyte (async)', (t) => {
 
   stream.on('finish', () => {
     readFile(dest, 'utf8', (err, data) => {
-      t.error(err)
-      t.equal(data, longString)
+      assert.ifError(err)
+      assert.strictEqual(data, longString)
+      done()
     })
   })
 
@@ -50,8 +51,7 @@ test('break up utf8 multibyte (async)', (t) => {
   stream.end()
 })
 
-test('break up utf8 multibyte several times bigger than write buffer', (t) => {
-  t.plan(2)
+test('break up utf8 multibyte several times bigger than write buffer', (t, done) => {
   const longString = '\u03A3'.repeat(32)
 
   const dest = file()
@@ -64,8 +64,9 @@ test('break up utf8 multibyte several times bigger than write buffer', (t) => {
 
   stream.on('finish', () => {
     readFile(dest, 'utf8', (err, data) => {
-      t.error(err)
-      t.equal(data, longString)
+      assert.ifError(err)
+      assert.strictEqual(data, longString)
+      done()
     })
   })
 

package/node_modules/thread-stream/test/multibyte-overrun.test.mjs

@@ -0,0 +1,33 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFile } from 'node:fs/promises'
+import ThreadStream from '../index.js'
+import { join } from 'desm'
+import { file } from './helper.js'
+
+test('preserves multibyte records that cross the buffer boundary', async () => {
+  const dest = file()
+  const stream = new ThreadStream({
+    bufferSize: 128,
+    filename: join(import.meta.url, 'to-file.js'),
+    workerData: { dest },
+    sync: false
+  })
+
+  let expected = ''
+
+  for (let i = 0; i < 1000; i++) {
+    const line = `{"idx":${i},"alert":"🚨"}\n`
+    expected += line
+    stream.write(line)
+  }
+
+  await new Promise((resolve, reject) => {
+    stream.once('error', reject)
+    stream.once('close', resolve)
+    stream.end()
+  })
+
+  const data = await readFile(dest, 'utf8')
+  assert.strictEqual(data, expected)
+})

package/node_modules/thread-stream/test/pkg/index.js

@@ -1,37 +1,37 @@
 'use strict'
 
 /**
- * This file is packaged using pkg in order to test if worker.js works in that context
+ * This file is packaged using pkg in order to test if worker.js works in that context.
+ * Note: We can't use node:test here because it crashes inside pkg bundles due to V8 internals.
  */
 
-const { test } = require('tap')
+const assert = require('node:assert')
 const { join } = require('path')
 const { file } = require('../helper')
 const ThreadStream = require('../..')
 
-test('bundlers support with .js file', function (t) {
-  t.plan(1)
+globalThis.__bundlerPathsOverrides = {
+  'thread-stream-worker': join(__dirname, '..', 'custom-worker.js')
+}
 
-  globalThis.__bundlerPathsOverrides = {
-    'thread-stream-worker': join(__dirname, '..', 'custom-worker.js')
-  }
+const dest = file()
 
-  const dest = file()
-
-  process.on('uncaughtException', (error) => {
-    console.log(error)
-  })
-
-  const stream = new ThreadStream({
-    filename: join(__dirname, '..', 'to-file.js'),
-    workerData: { dest },
-    sync: true
-  })
+process.on('uncaughtException', (error) => {
+  console.error(error)
+  process.exit(1)
+})
 
-  stream.worker.removeAllListeners('message')
-  stream.worker.once('message', (message) => {
-    t.equal(message.code, 'CUSTOM-WORKER-CALLED')
-  })
+const stream = new ThreadStream({
+  filename: join(__dirname, '..', 'to-file.js'),
+  workerData: { dest },
+  sync: true
+})
 
-  stream.end()
+stream.worker.removeAllListeners('message')
+stream.worker.once('message', (message) => {
+  assert.strictEqual(message.code, 'CUSTOM-WORKER-CALLED')
+  console.log('pkg test passed')
+  process.exit(0)
 })
+
+stream.end()

package/node_modules/thread-stream/test/pkg/pkg.config.json

@@ -5,10 +5,9 @@
             "../to-file.js"
         ],
         "targets": [
-            "node14",
-            "node16",
-            "node18",
-            "node20"
+            "node20",
+            "node22",
+            "node24"
         ],
         "outputPath": "test/pkg"
     }

package/node_modules/thread-stream/test/pkg/pkg.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
+const assert = require('node:assert')
 const config = require('./pkg.config.json')
 const { promisify } = require('util')
 const { unlink } = require('fs/promises')
@@ -8,7 +9,7 @@ const { join } = require('path')
 const { platform } = require('process')
 const exec = promisify(require('child_process').exec)
 
-test('worker test when packaged into executable using pkg', async (t) => {
+test('worker test when packaged into executable using pkg', async () => {
   const packageName = 'index'
 
   // package the app into several node versions, check config for more info
@@ -19,7 +20,7 @@ test('worker test when packaged into executable using pkg', async (t) => {
   const { stderr } = await exec(`npx pkg ${filePath} --config ${configPath}`)
 
   // there should be no error when packaging
-  t.equal(stderr, '')
+  assert.strictEqual(stderr, '')
 
   // pkg outputs files in the following format by default: {filename}-{node version}
   for (const target of config.pkg.targets) {
@@ -36,11 +37,9 @@ test('worker test when packaged into executable using pkg', async (t) => {
     const { stderr } = await exec(executablePath)
 
     // check if there were no errors
-    t.equal(stderr, '')
+    assert.strictEqual(stderr, '')
 
     // clean up afterwards
     await unlink(executablePath)
   }
-
-  t.end()
 })

package/node_modules/thread-stream/test/post-message.test.js

@@ -1,24 +1,23 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
+const assert = require('node:assert')
 const { join } = require('path')
 const { once } = require('events')
 const { MessageChannel } = require('worker_threads')
 const ThreadStream = require('..')
 
 test('message events emitted on the stream are posted to the worker', async function (t) {
-  t.plan(1)
-
   const { port1, port2 } = new MessageChannel()
   const stream = new ThreadStream({
     filename: join(__dirname, 'on-message.js'),
     sync: false
   })
-  t.teardown(() => {
+  t.after(() => {
     stream.end()
   })
 
   stream.emit('message', { text: 'hello', takeThisPortPlease: port1 }, [port1])
   const [confirmation] = await once(port2, 'message')
-  t.equal(confirmation, 'received: hello')
+  assert.strictEqual(confirmation, 'received: hello')
 })

package/node_modules/thread-stream/test/report-thread-name.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const { Writable } = require('stream')
+const { threadName, parentPort } = require('worker_threads')
+
+module.exports = function () {
+  parentPort.once('message', function ({ port }) {
+    port.postMessage({ threadName })
+  })
+
+  return new Writable({
+    write (chunk, encoding, callback) {
+      callback()
+    }
+  })
+}

package/node_modules/thread-stream/test/string-limit-2.test.js

@@ -1,12 +1,7 @@
 'use strict'
 
-const t = require('tap')
-
-if (process.env.CI) {
-  t.skip('skip on CI')
-  process.exit(0)
-}
-
+const { test } = require('node:test')
+const assert = require('node:assert')
 const { join } = require('path')
 const { file } = require('./helper')
 const { createReadStream } = require('fs')
@@ -15,27 +10,26 @@ const buffer = require('buffer')
 
 const MAX_STRING = buffer.constants.MAX_STRING_LENGTH
 
-t.plan(1)
-
-const dest = file()
-const stream = new ThreadStream({
-  filename: join(__dirname, 'to-file.js'),
-  workerData: { dest },
-  sync: false
-})
-
-stream.on('close', async () => {
-  t.comment('close emitted')
-  let buf
-  for await (const chunk of createReadStream(dest)) {
-    buf = chunk
-  }
-  t.equal('asd', buf.toString().slice(-3))
-})
-
-stream.on('ready', () => {
-  t.comment('open emitted')
-  stream.write('a'.repeat(MAX_STRING - 2))
-  stream.write('asd')
-  stream.end()
+test('string limit 2', { skip: process.env.CI }, (t, done) => {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest },
+    sync: false
+  })
+
+  stream.on('close', async () => {
+    let buf
+    for await (const chunk of createReadStream(dest)) {
+      buf = chunk
+    }
+    assert.strictEqual('asd', buf.toString().slice(-3))
+    done()
+  })
+
+  stream.on('ready', () => {
+    stream.write('a'.repeat(MAX_STRING - 2))
+    stream.write('asd')
+    stream.end()
+  })
 })

package/node_modules/thread-stream/test/string-limit.test.js

@@ -1,42 +1,37 @@
 'use strict'
 
-const t = require('tap')
-
-if (process.env.CI) {
-  t.skip('skip on CI')
-  process.exit(0)
-}
-
+const { test } = require('node:test')
+const assert = require('node:assert')
 const { join } = require('path')
 const { file } = require('./helper')
 const { stat } = require('fs')
 const ThreadStream = require('..')
 
-t.setTimeout(30000)
-
-const dest = file()
-const stream = new ThreadStream({
-  filename: join(__dirname, 'to-file.js'),
-  workerData: { dest },
-  sync: false
-})
+test('string limit', { skip: process.env.CI, timeout: 30000 }, (t, done) => {
+  const dest = file()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'to-file.js'),
+    workerData: { dest },
+    sync: false
+  })
 
-let length = 0
+  let length = 0
 
-stream.on('close', () => {
-  stat(dest, (err, f) => {
-    t.error(err)
-    t.equal(f.size, length)
-    t.end()
+  stream.on('close', () => {
+    stat(dest, (err, f) => {
+      assert.ifError(err)
+      assert.strictEqual(f.size, length)
+      done()
+    })
   })
-})
 
-const buf = Buffer.alloc(1024).fill('x').toString() // 1 KB
+  const buf = Buffer.alloc(1024).fill('x').toString() // 1 KB
 
-// This writes 1 GB of data
-for (let i = 0; i < 1024 * 1024; i++) {
-  length += buf.length
-  stream.write(buf)
-}
+  // This writes 1 GB of data
+  for (let i = 0; i < 1024 * 1024; i++) {
+    length += buf.length
+    stream.write(buf)
+  }
 
-stream.end()
+  stream.end()
+})