@withbuddi/buddi 0.1.0-pre.35 → 0.1.0-pre.37

package/node_modules/pino/test/multistream.test.js

@@ -414,6 +414,40 @@ test('clone generates a new multistream with all stream at the same level', asyn
   await plan
 })
 
+test('clone supports add, remove, and end methods correctly', async (t) => {
+  const plan = tspl(t, { plan: 5 })
+  const stream1 = writeStream(function (data, enc, cb) {
+    cb()
+  })
+  const stream2 = writeStream(function (data, enc, cb) {
+    cb()
+  })
+
+  const ms = multistream([{ stream: stream1 }])
+  const clone = ms.clone(30)
+
+  // Verify that adding a stream with a string level doesn't throw and returns the clone
+  const updatedClone = clone.add({ level: 'info', stream: stream2 })
+  plan.equal(updatedClone, clone)
+  plan.equal(clone.streams.length, 2)
+
+  // Verify remove returns the clone and works correctly
+  const stream2Entry = clone.streams.find(s => s.stream === stream2)
+  if (stream2Entry) {
+    const afterRemove = clone.remove(stream2Entry.id)
+    plan.equal(afterRemove, clone)
+    plan.equal(clone.streams.length, 1)
+  } else {
+    plan.fail('stream2 entry not found')
+  }
+
+  // Verify end method is present and can be called without errors
+  plan.equal(typeof clone.end, 'function')
+  clone.end()
+
+  await plan
+})
+
 test('one stream', async () => {
   let messageCount = 0
   const stream = writeStream(function (data, enc, cb) {
@@ -678,6 +712,36 @@ test('multistream.write should not throw if one stream fails', async () => {
   assert.equal(messageCount, 3)
 })
 
+test('write routes correctly when the source sets a string lastLevel', async () => {
+  // A source that formats levels as labels (e.g. pino-abstract-transport
+  // relaying lines produced with a `formatters.level` option) assigns the
+  // string label to `lastLevel` via the metadata protocol. multistream must
+  // resolve that label to a numeric value before comparing against the
+  // per-stream levels, otherwise the log line is silently dropped.
+  const received = []
+  const mkStream = (name) => writeStream(function (data, enc, cb) {
+    received.push(name)
+    cb()
+  })
+  const streams = [
+    { level: 'debug', stream: mkStream('debug') },
+    { level: 'error', stream: mkStream('error') }
+  ]
+  const multi = multistream(streams, { levels: pino.levels.values })
+
+  // Emulate the metadata protocol used by pino / pino-abstract-transport,
+  // but with a level label string instead of a number.
+  multi.lastLevel = 'error'
+  multi.lastMsg = 'boom'
+  multi.lastObj = {}
+  multi.lastTime = Date.now()
+  multi.write('{"level":"error","msg":"boom"}\n')
+
+  // An error-level record must reach both the debug (<= error) and error
+  // streams, exactly as it would when lastLevel is the numeric 50.
+  assert.deepStrictEqual(received.sort(), ['debug', 'error'])
+})
+
 test('flushSync', async (t) => {
   const plan = tspl(t, { plan: 2 })
   const tmp = file()

package/node_modules/pino/test/redact.test.js

@@ -891,3 +891,33 @@ test('censor function should not be called for non-existent nested paths (issue
   assert.equal(censorCalls[0].path, 'req.authorization')
   assert.equal(censorCalls[0].value, 'bearer token')
 })
+
+test('redact option – a path whose first segment names an Object.prototype member', async () => {
+  // The shape of the redactor is keyed by the first segment of each path, and
+  // those come from the caller. On a plain object 'constructor.secret' reads the
+  // inherited function, and building the logger threw
+  // "o[ns].push is not a function" before it could log anything.
+  const stream = sink()
+  const instance = pino({ redact: ['constructor.secret'] }, stream)
+  instance.info({ constructor: { secret: 'hunter2', keep: 'me' } }, 'hello')
+  const o = await once(stream, 'data')
+  assert.equal(o.constructor.secret, '[Redacted]')
+  assert.equal(o.constructor.keep, 'me')
+})
+
+test('redact option – other inherited names no longer throw while building', async () => {
+  for (const name of ['toString', 'valueOf', 'hasOwnProperty', 'isPrototypeOf', '__proto__']) {
+    assert.doesNotThrow(() => {
+      pino({ redact: [`${name}.secret`] }, sink())
+    }, `redact path under ${name}`)
+  }
+})
+
+test('redact option – top level path named after an Object.prototype member', async () => {
+  const stream = sink()
+  const instance = pino({ redact: ['constructor'] }, stream)
+  instance.info({ constructor: 'hunter2', keep: 'me' }, 'hello')
+  const o = await once(stream, 'data')
+  assert.equal(o.constructor, '[Redacted]')
+  assert.equal(o.keep, 'me')
+})

package/node_modules/pino/test/smoke.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const { execSync } = require('node:child_process')
+const { mkdtempSync, rmSync, writeFileSync, readFileSync } = require('node:fs')
+const { tmpdir } = require('node:os')
+const { join } = require('node:path')
+
+const rootDir = join(__dirname, '..')
+const pkg = JSON.parse(readFileSync(join(rootDir, 'package.json'), 'utf8'))
+
+const smokeFiles = ['pino.js', 'browser.js', 'file.js']
+
+const tmpDir = mkdtempSync(join(tmpdir(), 'pino-smoke-'))
+
+function run (command, cwd) {
+  return execSync(command, { cwd, stdio: 'pipe', encoding: 'utf8' })
+}
+
+function tarballName (name, version) {
+  const safeName = name.startsWith('@')
+    ? name.slice(1).replace('/', '-')
+    : name
+  return `${safeName}-${version}.tgz`
+}
+
+try {
+  console.log(`Working in ${tmpDir}`)
+
+  run(`npm pack --pack-destination "${tmpDir}"`, rootDir)
+  const filename = tarballName(pkg.name, pkg.version)
+  const tarballPath = join(tmpDir, filename)
+  console.log(`Packed: ${filename}`)
+
+  writeFileSync(
+    join(tmpDir, 'package.json'),
+    JSON.stringify({ name: 'pino-smoke-test', version: '1.0.0', private: true }, null, 2)
+  )
+  run(`npm install --no-audit --no-fund "${tarballPath}"`, tmpDir)
+  console.log(`Installed ${pkg.name}@${pkg.version} from tarball`)
+
+  const installedRoot = join(tmpDir, 'node_modules', pkg.name)
+  for (const file of smokeFiles) {
+    const target = join(installedRoot, file)
+    console.log(`Running node ${file}...`)
+    run(`"${process.execPath}" "${target}"`, tmpDir)
+  }
+
+  console.log('\nAll smoke tests passed')
+} catch (err) {
+  console.error('\nSmoke test failed:')
+  if (err.stdout) console.error(err.stdout.toString())
+  if (err.stderr) console.error(err.stderr.toString())
+  console.error(err.message)
+  process.exitCode = 1
+} finally {
+  try {
+    rmSync(tmpDir, { recursive: true, force: true, maxRetries: 3 })
+  } catch {}
+}

package/node_modules/pino/test/transport/core.test.js

@@ -267,6 +267,59 @@ test('pino.transport with two files and dedupe', async (t) => {
   })
 })
 
+test('pino.transport with single target in targets array honors level filter (#1996)', async (t) => {
+  const destination = file()
+  const transport = pino.transport({
+    targets: [{
+      level: 'error',
+      target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
+      options: { destination }
+    }]
+  })
+  t.after(transport.end.bind(transport))
+  const instance = pino({ level: 'debug' }, transport)
+  instance.debug('debug-msg')
+  instance.info('info-msg')
+  instance.warn('warn-msg')
+  instance.error('error-msg')
+  await watchForWrite(destination, 'error-msg')
+  const lines = (await readFile(destination, 'utf8')).trim().split('\n').filter(Boolean)
+  assert.equal(lines.length, 1, 'only error should be written to destination')
+  const result = JSON.parse(lines[0])
+  delete result.time
+  assert.deepEqual(result, {
+    pid,
+    hostname,
+    level: 50,
+    msg: 'error-msg'
+  })
+})
+
+test('pino.transport with single target in targets array without level keeps logger.level gating', async (t) => {
+  const destination = file()
+  const transport = pino.transport({
+    targets: [{
+      target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
+      options: { destination }
+    }]
+  })
+  t.after(transport.end.bind(transport))
+  const instance = pino({ level: 'debug' }, transport)
+  instance.debug('debug-msg')
+  instance.info('info-msg')
+  await watchForWrite(destination, 'info-msg')
+  const lines = (await readFile(destination, 'utf8')).trim().split('\n').filter(Boolean)
+  assert.equal(lines.length, 2, 'both debug and info reach the single target when no per-target level is set')
+  const first = JSON.parse(lines[0])
+  delete first.time
+  assert.deepEqual(first, {
+    pid,
+    hostname,
+    level: 20,
+    msg: 'debug-msg'
+  })
+})
+
 test('pino.transport with an array including a pino-pretty destination', async (t) => {
   const dest1 = file()
   const dest2 = file()
@@ -496,6 +549,38 @@ test('sets worker data informing the transport that pino will send its config (f
   await plan
 })
 
+test('warns when custom formatters.level is incompatible with multi-target transport routing', async (t) => {
+  const warnings = []
+  const originalEmitWarning = process.emitWarning
+  process.emitWarning = function (warning, options) {
+    warnings.push({ warning, options })
+  }
+  t.after(() => {
+    process.emitWarning = originalEmitWarning
+  })
+
+  const transport = pino.transport({
+    targets: [
+      { target: join(__dirname, '..', 'fixtures', 'noop-transport.js') },
+      { target: join(__dirname, '..', 'fixtures', 'noop-transport.js') }
+    ]
+  })
+  t.after(transport.end.bind(transport))
+
+  const instance = pino({
+    formatters: {
+      level (label) {
+        return { severity: label }
+      }
+    }
+  }, transport)
+
+  instance.info('hello')
+
+  assert.equal(warnings.length, 1)
+  assert.equal(warnings[0].options.code, 'PINO_TRANSPORT_MULTI_TARGETS_LEVEL_FORMATTER')
+})
+
 test('stdout in worker', async () => {
   let actual = ''
   const child = execa(process.argv[0], [join(__dirname, '..', 'fixtures', 'transport-main.js')])

package/node_modules/pino/test/transport/sync-false.test.js

@@ -6,6 +6,7 @@ const os = require('node:os')
 const { join } = require('node:path')
 const { readFile } = require('node:fs').promises
 const { promisify } = require('node:util')
+const { once } = require('node:events')
 
 const pino = require('../..')
 const { watchFileCreated, watchForWrite, file } = require('../helper')
@@ -47,6 +48,14 @@ test('thread-stream async flush should call the passed callback', async () => {
   const instance = pino(transport)
   const flushPromise = promisify(instance.flush).bind(instance)
 
+  // The worker thread backing the transport is unref'd once it becomes ready
+  // (see lib/transport.js) so it does not keep the process alive. Because this
+  // test awaits `flush()` on an otherwise idle event loop, re-ref the worker
+  // after it is ready so the loop stays alive until the flush callback runs;
+  // otherwise the awaited promise never settles and the test hangs.
+  await once(transport, 'ready')
+  transport.ref()
+
   instance.info('hello')
   await flushPromise()
   await watchFileCreated(outputPath)
@@ -64,4 +73,7 @@ test('thread-stream async flush should call the passed callback', async () => {
   const afterSecondFlush = await getOutputLogLines()
   assert.equal(afterSecondFlush.length, 2)
   assert.equal(afterSecondFlush[1].msg, 'world')
+
+  // Restore the unref'd state so the test process can exit cleanly.
+  transport.unref()
 })

package/node_modules/pino/test/transport/uses-pino-config.test.js

@@ -7,7 +7,7 @@ const { join } = require('node:path')
 const { readFile } = require('node:fs').promises
 const writeStream = require('flush-write-stream')
 
-const { watchFileCreated, file } = require('../helper')
+const { watchForWrite, file } = require('../helper')
 const pino = require('../../')
 
 const { pid } = process
@@ -45,7 +45,7 @@ test('transport uses pino config', async (t) => {
   const error = new Error('bar')
   instance.custom('foo')
   instance.error(error)
-  await watchFileCreated(destination)
+  await watchForWrite(destination, '"body":"bar"')
   const result = parseLogs(await readFile(destination))
 
   assert.deepEqual(result, [{
@@ -82,7 +82,7 @@ test('transport uses pino config without customizations', async (t) => {
   const error = new Error('qux')
   instance.info('baz')
   instance.error(error)
-  await watchFileCreated(destination)
+  await watchForWrite(destination, '"body":"qux"')
   const result = parseLogs(await readFile(destination))
 
   assert.deepEqual(result, [{
@@ -131,7 +131,7 @@ test('transport uses pino config with multistream', async (t) => {
   const serializedError = serializeError(error)
   instance.custom('fizz')
   instance.error(error)
-  await watchFileCreated(destination)
+  await watchForWrite(destination, '"body":"buzz"')
   const result = parseLogs(await readFile(destination))
 
   assert.deepEqual(result, [{

package/node_modules/pino/test/types/pino-import.tst.cts

@@ -0,0 +1,30 @@
+import { expect } from 'tstyche'
+
+import * as pinoStar from '../../pino.js'
+import pinoDefault, { default as pino, pino as pinoNamed } from '../../pino.js'
+import pinoCjsImport = require ('../../pino.js')
+
+const log = pino()
+expect(log.info).type.toBe<pino.LogFn>()
+expect(log.error).type.toBe<pino.LogFn>()
+
+expect(pinoDefault()).type.toBe<pino.Logger>()
+expect(pinoNamed()).type.toBe<pino.Logger>()
+expect(pinoStar.default()).type.toBe<pino.Logger>()
+expect(pinoStar.pino()).type.toBe<pino.Logger>()
+expect(pinoCjsImport()).type.toBe<pino.Logger>()
+expect(pinoCjsImport.default()).type.toBe<pino.Logger>()
+expect(pinoCjsImport.pino()).type.toBe<pino.Logger>()
+
+expect(pinoDefault.stdTimeFunctions.isoTimeNano()).type.toBe<string>()
+expect(pinoNamed.stdTimeFunctions.isoTimeNano()).type.toBe<string>()
+expect(pinoStar.stdTimeFunctions.isoTimeNano()).type.toBe<string>()
+expect(pinoCjsImport.stdTimeFunctions.isoTimeNano()).type.toBe<string>()
+
+const levelChangeEventListener: pino.LevelChangeEventListener = (
+    lvl: pino.LevelWithSilent | string,
+    val: number,
+    prevLvl: pino.LevelWithSilent | string,
+    prevVal: number,
+) => {}
+expect(levelChangeEventListener).type.toBe<pino.LevelChangeEventListener>()

package/node_modules/pino/test/types/pino-import.tst.js

@@ -0,0 +1,73 @@
+// @ts-check
+
+const {
+  pino,
+  destination,
+  levels,
+  multistream,
+  stdSerializers,
+  stdTimeFunctions,
+  transport,
+  version
+} = require('../../pino.js')
+const { default: pinoDefault } = require('../../pino.js')
+const pinoCjs = require('../../pino.js')
+
+const log = pino()
+log.info('test')
+log.error('test')
+
+const logDefault = pinoDefault()
+logDefault.info('test')
+logDefault.error('test')
+
+const logCjs = pinoCjs()
+logCjs.info('test')
+logCjs.error('test')
+
+destination()
+pino.destination()
+pinoDefault.destination()
+pinoCjs.destination()
+
+levels
+pino.levels
+pinoDefault.levels
+pinoCjs.levels
+
+multistream(process.stdout)
+pino.multistream(process.stdout)
+pinoDefault.multistream(process.stdout)
+pinoCjs.multistream(process.stdout)
+
+stdSerializers.err(new Error())
+pino.stdSerializers.err(new Error())
+pinoDefault.stdSerializers.err(new Error())
+pinoCjs.stdSerializers.err(new Error())
+
+stdTimeFunctions.epochTime()
+pino.stdTimeFunctions.epochTime()
+pinoDefault.stdTimeFunctions.epochTime()
+pinoCjs.stdTimeFunctions.epochTime()
+
+transport({
+  target: '#pino/pretty',
+  options: { some: 'options for', the: 'transport' }
+})
+pino.transport({
+  target: '#pino/pretty',
+  options: { some: 'options for', the: 'transport' }
+})
+pinoDefault.transport({
+  target: '#pino/pretty',
+  options: { some: 'options for', the: 'transport' }
+})
+pinoCjs.transport({
+  target: '#pino/pretty',
+  options: { some: 'options for', the: 'transport' }
+})
+
+version
+pino.version
+pinoDefault.version
+pinoCjs.version

package/node_modules/pino/test/types/pino-multistream.tst.ts

@@ -0,0 +1,49 @@
+import { expect } from 'tstyche'
+
+import { createWriteStream } from 'node:fs'
+
+import pino, { multistream } from '../../pino.js'
+
+const streams = [
+  { stream: process.stdout },
+  { stream: createWriteStream('') },
+  { level: 'error' as const, stream: process.stderr },
+  { level: 'fatal' as const, stream: process.stderr }
+]
+
+expect(pino.multistream(process.stdout)).type.toBe<pino.MultiStreamRes>()
+expect(
+  pino.multistream([createWriteStream('')])
+).type.toBe<pino.MultiStreamRes>()
+expect(
+  pino.multistream({ level: 'error' as const, stream: process.stderr })
+).type.toBe<pino.MultiStreamRes<'error'>>()
+expect(
+  pino.multistream([
+    { level: 'fatal' as const, stream: createWriteStream('') }
+  ])
+).type.toBe<pino.MultiStreamRes<'fatal'>>()
+
+expect(pino.multistream(streams)).type.toBe<
+  pino.MultiStreamRes<'error' | 'fatal'>
+>()
+expect(pino.multistream(streams, {})).type.toBe<
+  pino.MultiStreamRes<'error' | 'fatal'>
+>()
+expect(pino.multistream(streams, { levels: { info: 30 } })).type.toBe<
+  pino.MultiStreamRes<'error' | 'fatal'>
+>()
+expect(pino.multistream(streams, { dedupe: true })).type.toBe<
+  pino.MultiStreamRes<'error' | 'fatal'>
+>()
+expect(pino.multistream(streams[0]).add(streams[1])).type.toBe<
+  pino.MultiStreamRes<'error' | 'fatal'>
+>()
+expect(multistream(streams)).type.toBe<
+  pino.MultiStreamRes<'error' | 'fatal'>
+>()
+expect(multistream(streams).clone('error')).type.toBe<
+  pino.MultiStreamRes<'error'>
+>()
+
+expect(multistream(process.stdout)).type.toBe<pino.MultiStreamRes>()

package/node_modules/pino/test/types/pino-top-export.tst.ts

@@ -0,0 +1,32 @@
+import { expect } from 'tstyche'
+
+import type { SonicBoom } from 'sonic-boom'
+import type ThreadStream from 'thread-stream'
+
+import {
+  destination,
+  type LevelMapping,
+  levels,
+  multistream,
+  type MultiStreamRes,
+  type SerializedError,
+  stdSerializers,
+  stdTimeFunctions,
+  transport,
+  version
+} from '../../pino.js'
+
+expect(destination('')).type.toBe<SonicBoom>()
+expect(levels).type.toBe<LevelMapping>()
+expect(multistream(process.stdout)).type.toBe<MultiStreamRes>()
+expect(stdSerializers.err({} as Error)).type.toBe<SerializedError>()
+expect(stdTimeFunctions.isoTime()).type.toBe<string>()
+expect(stdTimeFunctions.isoTimeNano()).type.toBe<string>()
+expect(version).type.toBe<string>()
+
+expect(
+  transport({
+    target: '#pino/pretty',
+    options: { some: 'options for', the: 'transport' }
+  })
+).type.toBe<ThreadStream>()