@zuplo/cli 6.69.10 → 6.69.11

package/node_modules/pino-http/node_modules/thread-stream/index.js

@@ -18,6 +18,8 @@ const kImpl = Symbol('kImpl')
 // V8 limit for string size
 const MAX_STRING = buffer.constants.MAX_STRING_LENGTH
 
+function noop () {}
+
 class FakeWeakRef {
   constructor (value) {
     this._value = value
@@ -54,6 +56,7 @@ function createWorker (stream, opts) {
 
   const worker = new Worker(toExecute, {
     ...opts.workerOpts,
+    name: opts.workerOpts?.name || 'thread-stream',
     trackUnmanagedFds: false,
     workerData: {
       filename: filename.indexOf('file://') === 0
@@ -114,8 +117,8 @@ function nextFlush (stream) {
       write(stream, toWrite, nextFlush.bind(null, stream))
     } else {
       // multi-byte utf-8
-      stream.flush(() => {
-        // err is already handled in flush()
+      waitForRead(stream, () => {
+        // err is already handled in waitForRead()
         if (stream.destroyed) {
           return
         }
@@ -141,7 +144,7 @@ function nextFlush (stream) {
       // we had a flushSync in the meanwhile
       return
     }
-    stream.flush(() => {
+    waitForRead(stream, () => {
       Atomics.store(stream[kImpl].state, READ_INDEX, 0)
       Atomics.store(stream[kImpl].state, WRITE_INDEX, 0)
       Atomics.notify(stream[kImpl].state, READ_INDEX)
@@ -162,13 +165,19 @@ function onWorkerMessage (msg) {
     return
   }
 
+  // Node.js watch mode may send internal worker messages that do not
+  // participate in thread-stream's worker protocol.
+  if (msg?.code == null) {
+    return
+  }
+
   switch (msg.code) {
     case 'READY':
       // Replace the FakeWeakRef with a
       // proper one.
       this.stream = new WeakRef(stream)
 
-      stream.flush(() => {
+      waitForRead(stream, () => {
         stream[kImpl].ready = true
         stream.emit('ready')
       })
@@ -183,6 +192,19 @@ function onWorkerMessage (msg) {
         stream.emit(msg.name, msg.args)
       }
       break
+    case 'FLUSHED': {
+      if (msg.context !== 'thread-stream') {
+        destroy(stream, new Error('this should not happen: ' + msg.code))
+        break
+      }
+
+      const cb = stream[kImpl].flushCallbacks.get(msg.id)
+      if (cb) {
+        stream[kImpl].flushCallbacks.delete(msg.id)
+        process.nextTick(cb)
+      }
+      break
+    }
     case 'WARNING':
       process.emitWarning(msg.err)
       break
@@ -227,6 +249,8 @@ class ThreadStream extends EventEmitter {
     this[kImpl].errored = null
     this[kImpl].closed = false
     this[kImpl].buf = ''
+    this[kImpl].flushCallbacks = new Map()
+    this[kImpl].nextFlushId = 0
 
     // TODO (fix): Make private?
     this.worker = createWorker(this, opts) // TODO (fix): make private
@@ -287,28 +311,15 @@ class ThreadStream extends EventEmitter {
   }
 
   flush (cb) {
-    if (this[kImpl].destroyed) {
-      if (typeof cb === 'function') {
-        process.nextTick(cb, new Error('the worker has exited'))
-      }
-      return
-    }
+    cb = typeof cb === 'function' ? cb : noop
 
-    // TODO write all .buf
-    const writeIndex = Atomics.load(this[kImpl].state, WRITE_INDEX)
-    // process._rawDebug(`(flush) readIndex (${Atomics.load(this.state, READ_INDEX)}) writeIndex (${Atomics.load(this.state, WRITE_INDEX)})`)
-    wait(this[kImpl].state, READ_INDEX, writeIndex, Infinity, (err, res) => {
+    flushBuffer(this, (err) => {
       if (err) {
-        destroy(this, err)
         process.nextTick(cb, err)
         return
       }
-      if (res === 'not-equal') {
-        // TODO handle deadlock
-        this.flush(cb)
-        return
-      }
-      process.nextTick(cb)
+
+      requestWorkerFlush(this, cb)
     })
   }
 
@@ -366,6 +377,93 @@ class ThreadStream extends EventEmitter {
   }
 }
 
+function flushBuffer (stream, cb) {
+  if (stream[kImpl].destroyed) {
+    process.nextTick(cb, new Error('the worker has exited'))
+    return
+  }
+
+  if (!stream[kImpl].sync && (stream[kImpl].flushing || stream[kImpl].buf.length > 0)) {
+    setImmediate(flushBuffer, stream, cb)
+    return
+  }
+
+  waitForRead(stream, cb)
+}
+
+function waitForRead (stream, cb) {
+  const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX)
+  wait(stream[kImpl].state, READ_INDEX, writeIndex, Infinity, (err, res) => {
+    if (err) {
+      destroy(stream, err)
+      cb(err)
+      return
+    }
+
+    if (res !== 'ok') {
+      waitForRead(stream, cb)
+      return
+    }
+
+    cb()
+  })
+}
+
+function requestWorkerFlush (stream, cb) {
+  if (stream[kImpl].destroyed) {
+    process.nextTick(cb, new Error('the worker has exited'))
+    return
+  }
+
+  if (!stream[kImpl].ready) {
+    const onReady = () => {
+      cleanup()
+      requestWorkerFlush(stream, cb)
+    }
+    const onClose = () => {
+      cleanup()
+      process.nextTick(cb, new Error('the worker has exited'))
+    }
+    const cleanup = () => {
+      stream.off('ready', onReady)
+      stream.off('close', onClose)
+    }
+
+    stream.once('ready', onReady)
+    stream.once('close', onClose)
+    return
+  }
+
+  const id = ++stream[kImpl].nextFlushId
+  stream[kImpl].flushCallbacks.set(id, cb)
+
+  try {
+    stream.worker.postMessage({
+      code: 'FLUSH',
+      context: 'thread-stream',
+      id
+    })
+  } catch (err) {
+    stream[kImpl].flushCallbacks.delete(id)
+    destroy(stream, err)
+    process.nextTick(cb, err)
+  }
+}
+
+function failPendingFlushCallbacks (stream, err) {
+  const callbacks = stream[kImpl].flushCallbacks
+  if (callbacks.size === 0) {
+    return
+  }
+
+  const flushErr = err || new Error('the worker has exited')
+
+  for (const cb of callbacks.values()) {
+    process.nextTick(cb, flushErr)
+  }
+  callbacks.clear()
+}
+
 function error (stream, err) {
   setImmediate(() => {
     stream.emit('error', err)
@@ -377,6 +475,7 @@ function destroy (stream, err) {
     return
   }
   stream[kImpl].destroyed = true
+  failPendingFlushCallbacks(stream, err)
 
   if (err) {
     stream[kImpl].errored = err

package/node_modules/pino-http/node_modules/thread-stream/lib/worker.js

@@ -12,6 +12,8 @@ const {
 } = workerData
 
 let destination
+const flushQueue = []
+let flushing = false
 
 const state = new Int32Array(stateBuf)
 const data = Buffer.from(dataBuf)
@@ -19,6 +21,101 @@ const data = Buffer.from(dataBuf)
 // Keep the event loop alive - Atomics.waitAsync promises don't prevent worker exit
 const keepAlive = setInterval(() => {}, 60 * 60 * 1000)
 
+function onParentPortMessage (msg) {
+  if (!msg || msg.code !== 'FLUSH' || msg.context !== 'thread-stream') {
+    return
+  }
+
+  flushQueue.push(msg.id)
+  processFlushQueue()
+}
+
+function processFlushQueue () {
+  if (flushing || !destination) {
+    return
+  }
+
+  const id = flushQueue.shift()
+  if (id === undefined) {
+    return
+  }
+
+  flushing = true
+  flushDestination((err) => {
+    flushing = false
+
+    if (err) {
+      parentPort.postMessage({
+        code: 'ERROR',
+        err
+      })
+      return
+    }
+
+    parentPort.postMessage({
+      code: 'FLUSHED',
+      context: 'thread-stream',
+      id
+    })
+
+    processFlushQueue()
+  })
+}
+
+function flushDestination (cb) {
+  if (typeof destination?.flush === 'function') {
+    if (destination.flush.length === 0) {
+      try {
+        const result = destination.flush()
+        if (result && typeof result.then === 'function') {
+          result.then(() => cb(), cb)
+        } else {
+          cb()
+        }
+      } catch (err) {
+        cb(err)
+      }
+      return
+    }
+
+    let done = false
+    const onDone = (err) => {
+      if (done) {
+        return
+      }
+      done = true
+      cb(err)
+    }
+
+    try {
+      const result = destination.flush(onDone)
+      if (result && typeof result.then === 'function') {
+        result.then(() => onDone(), onDone)
+      }
+    } catch (err) {
+      onDone(err)
+    }
+    return
+  }
+
+  if (typeof destination?.flushSync === 'function') {
+    try {
+      destination.flushSync()
+      cb()
+    } catch (err) {
+      cb(err)
+    }
+    return
+  }
+
+  if (destination?.writableNeedDrain && !destination?.writableEnded) {
+    destination.once('drain', cb)
+    return
+  }
+
+  cb()
+}
+
 async function start () {
   let worker
   try {
@@ -93,12 +190,16 @@ async function start () {
       process.exit(0)
     })
   })
+
+  processFlushQueue()
 }
 
 // No .catch() handler,
 // in case there is an error it goes
 // to unhandledRejection
 start().then(function () {
+  parentPort.on('message', onParentPortMessage)
+
   parentPort.postMessage({
     code: 'READY'
   })

package/node_modules/pino-http/node_modules/thread-stream/node_modules/real-require/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Paolo Insogna and the real-require contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/pino-http/node_modules/thread-stream/node_modules/real-require/README.md

@@ -0,0 +1,51 @@
+# real-require
+
+Keep require and import consistent after bundling or transpiling.
+
+## Installation
+
+Just run:
+
+```bash
+npm install real-require
+```
+
+## Usage
+
+The package provides two drop-ins functions, `realRequire` and `realImport`,
+which can be used in scenarios where tools like transpilers or bundlers change
+the native `require` or `await import` calls.
+
+The current `realRequire` functions only handles webpack at the moment, wrapping
+the `__non_webpack__require__` implementation that webpack provides for the
+final bundle.
+
+### Example
+
+```js
+// After bundling, real-require will be embedded in the bundle
+const { realImport, realRequire } = require('real-require')
+
+/*
+  By using realRequire, at build time the module will not be embedded and at runtime it will try to load path from the local filesytem.
+  This is useful in situations where the build tool does not support skipping modules to embed.
+*/
+const { join } = realRequire('path')
+
+async function main() {
+  // Similarly, this make sure the import call is not modified by the build tools
+  const localFunction = await realImport('./source.js')
+
+  localFunction()
+}
+
+main().catch(console.error)
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md)
+
+## License
+
+Copyright Paolo Insogna and real-require contributors 2021. Licensed under the [MIT License](http://www.apache.org/licenses/MIT).

package/node_modules/pino-http/node_modules/thread-stream/node_modules/real-require/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "real-require",
+  "version": "1.0.0",
+  "description": "Keep require and import consistent after bundling or transpiling",
+  "author": "Paolo Insogna <shogun@cowtech.it>",
+  "homepage": "https://github.com/pinojs/real-require",
+  "contributors": [
+    {
+      "name": "Paolo Insogna",
+      "url": "https://github.com/ShogunPanda"
+    }
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pinojs/real-require.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pinojs/real-require/issues"
+  },
+  "main": "src/index.js",
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "test": "c8 --reporter=text --reporter=html borp 'test/*.test.js'",
+    "test:ci": "c8 --reporter=text --reporter=json --check-coverage --branches 90 --functions 90 --lines 90 --statements 90 borp 'test/*.test.js'",
+    "ci": "npm run lint && npm run test:ci"
+  },
+  "devDependencies": {
+    "borp": "^1.0.0",
+    "c8": "^8.0.0",
+    "eslint": "^9.39.4",
+    "neostandard": "^0.13.0"
+  }
+}

package/node_modules/pino-http/node_modules/thread-stream/node_modules/real-require/src/index.js

@@ -0,0 +1,14 @@
+/* eslint-disable no-new-func */
+/* globals __non_webpack__require__ */
+
+const realImport = new Function('modulePath', 'return import(modulePath)')
+
+function realRequire (modulePath) {
+  if (typeof __non_webpack__require__ === 'function') {
+    return __non_webpack__require__(modulePath)
+  }
+
+  return require(modulePath)
+}
+
+module.exports = { realImport, realRequire }

package/node_modules/pino-http/node_modules/thread-stream/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thread-stream",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "A streaming way to send data to a Node.js Worker Thread",
   "main": "index.js",
   "types": "index.d.ts",
@@ -8,30 +8,28 @@
     "node": ">=20"
   },
   "dependencies": {
-    "real-require": "^0.2.0"
+    "real-require": "^1.0.0"
   },
   "devDependencies": {
-    "@types/node": "^22.0.0",
+    "@types/node": "^25.0.2",
     "@yao-pkg/pkg": "^6.0.0",
-    "borp": "^0.21.0",
+    "borp": "^1.0.0",
     "desm": "^1.3.0",
     "eslint": "^9.39.1",
     "fastbench": "^1.0.1",
-    "husky": "^9.0.6",
-    "neostandard": "^0.12.2",
+    "neostandard": "^0.13.0",
     "pino-elasticsearch": "^8.0.0",
-    "sonic-boom": "^4.0.1",
+    "sonic-boom": "^5.0.0",
     "ts-node": "^10.8.0",
     "typescript": "~5.7.3"
   },
   "scripts": {
     "build": "tsc --noEmit",
     "lint": "eslint",
-    "test": "npm run lint && npm run build && npm run transpile && borp --pattern 'test/*.test.{js,mjs}'",
-    "test:ci": "npm run lint && npm run transpile && borp --pattern 'test/*.test.{js,mjs}'",
-    "test:yarn": "npm run transpile && borp --pattern 'test/*.test.js'",
-    "transpile": "sh ./test/ts/transpile.sh",
-    "prepare": "husky install"
+    "test": "npm run lint && npm run build && npm run transpile && borp --pattern \"test/*.test.{js,mjs}\"",
+    "test:ci": "npm run lint && npm run transpile && borp --pattern \"test/*.test.{js,mjs}\"",
+    "test:yarn": "npm run transpile && borp --pattern \"test/*.test.js\"",
+    "transpile": "sh ./test/ts/transpile.sh"
   },
   "repository": {
     "type": "git",

package/node_modules/pino-http/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/pino-http/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
+})