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

package/node_modules/pino/pino.js

@@ -43,8 +43,7 @@ const {
   hooksSym,
   nestedKeyStrSym,
   mixinMergeStrategySym,
-  msgPrefixSym,
-  transportUsesMultistreamSym
+  msgPrefixSym
 } = symbols
 const { epochTime, nullTime } = time
 const { pid } = process
@@ -131,9 +130,7 @@ function pino (...args) {
   const stringifyFn = stringify.bind({
     [stringifySafeSym]: stringifySafe
   })
-  const stringifiers = redact
-    ? Object.assign(Object.create(null), redaction(redact, stringifyFn))
-    : Object.create(null)
+  const stringifiers = redact ? redaction(redact, stringifyFn) : {}
   const formatOpts = redact
     ? { stringify: stringifiers[redactFmtSym] }
     : { stringify: stringifyFn }
@@ -168,28 +165,6 @@ function pino (...args) {
   assertDefaultLevelFound(level, customLevels, useOnlyCustomLevels)
   const levels = mappings(customLevels, useOnlyCustomLevels)
 
-  if (stream && stream[transportUsesMultistreamSym] === true) {
-    let sampleLabel = typeof level === 'string' ? level : undefined
-    if (!sampleLabel || levels[sampleLabel] === undefined) {
-      sampleLabel = Object.keys(levels)[0]
-    }
-    const sampleNumber = levels[sampleLabel]
-    let ok = false
-    try {
-      const formatted = formatters.level(sampleLabel, sampleNumber)
-      ok = formatted && typeof formatted === 'object' && formatted.level === sampleNumber
-    } catch {
-      ok = false
-    }
-
-    if (!ok) {
-      process.emitWarning(
-        'custom formatters.level detected with multiple transport targets/pipelines; ensure logs include a numeric "level" field or they may be dropped',
-        { code: 'PINO_TRANSPORT_MULTI_TARGETS_LEVEL_FORMATTER' }
-      )
-    }
-  }
-
   if (typeof stream.emit === 'function') {
     stream.emit('message', { code: 'PINO_CONFIG', config: { levels, messageKey, errorKey } })
   }

package/node_modules/pino/test/basic.test.js

@@ -884,69 +884,3 @@ test('grandchild message should inherent parent prefix', async () => {
   const { msg } = await once(stream, 'data')
   assert.equal(msg, 'My name is Bond James Bond')
 })
-
-test('logs an object with an own enumerable __proto__ key', async () => {
-  const stream = sink()
-  const instance = pino(stream)
-  // JSON.parse produces an own enumerable __proto__ key from any untrusted JSON
-  const obj = JSON.parse('{"__proto__":{"x":1},"user":"bob"}')
-  instance.info(obj, 'incoming request')
-  const result = await once(stream, 'data')
-  check(assert.equal.bind(assert), result, 30, 'incoming request')
-  assert.equal(result.user, 'bob')
-})
-
-test('logs a redacted object with an own enumerable __proto__ key', async () => {
-  const stream = sink()
-  const instance = pino({ redact: ['user'] }, stream)
-  const obj = JSON.parse('{"__proto__":{"x":1},"user":"bob"}')
-  instance.info(obj, 'incoming request')
-  const result = await once(stream, 'data')
-  check(assert.equal.bind(assert), result, 30, 'incoming request')
-  assert.equal(result.user, '[Redacted]')
-})
-
-test('logs child bindings with an own enumerable __proto__ key', async () => {
-  const stream = sink()
-  const bindings = JSON.parse('{"__proto__":{"x":1},"reqId":"abc"}')
-  const instance = pino(stream).child(bindings)
-  instance.info('incoming request')
-  const result = await once(stream, 'data')
-  check(assert.equal.bind(assert), result, 30, 'incoming request')
-  assert.equal(result.reqId, 'abc')
-})
-
-test('logs an object with keys named after Object.prototype members', async () => {
-  const stream = sink()
-  const instance = pino(stream)
-  const obj = {
-    toString: 'a',
-    constructor: 'b',
-    valueOf: 'c',
-    hasOwnProperty: 'd',
-    propertyIsEnumerable: 'e',
-    toLocaleString: 'f',
-    isPrototypeOf: 'g'
-  }
-  instance.info(obj, 'incoming request')
-  const result = await once(stream, 'data')
-  check(assert.equal.bind(assert), result, 30, 'incoming request')
-  assert.equal(result.toString, 'a')
-  assert.equal(result.constructor, 'b')
-  assert.equal(result.valueOf, 'c')
-  assert.equal(result.hasOwnProperty, 'd')
-  assert.equal(result.propertyIsEnumerable, 'e')
-  assert.equal(result.toLocaleString, 'f')
-  assert.equal(result.isPrototypeOf, 'g')
-})
-
-test('logs a redacted object with keys named after Object.prototype members', async () => {
-  const stream = sink()
-  const instance = pino({ redact: ['secret'] }, stream)
-  instance.info({ toString: 'a', valueOf: 'b', secret: 'x' }, 'incoming request')
-  const result = await once(stream, 'data')
-  check(assert.equal.bind(assert), result, 30, 'incoming request')
-  assert.equal(result.toString, 'a')
-  assert.equal(result.valueOf, 'b')
-  assert.equal(result.secret, '[Redacted]')
-})

package/node_modules/pino/test/escaping.test.js

@@ -36,23 +36,6 @@ testEscape('\\r', '\r')
 testEscape('\\t', '\t')
 testEscape('\\b', '\b')
 
-test('correctly escape child binding keys', async () => {
-  const stream = sink()
-  const key = 'x"}\n{"level":60,"msg":"forged"}\n{"swallow'
-  const instance = pino(stream).child({ [key]: true })
-
-  instance.info('hello')
-  const result = await once(stream, 'data')
-  delete result.time
-  assert.deepEqual(result, {
-    pid,
-    hostname,
-    level: 30,
-    msg: 'hello',
-    [key]: true
-  })
-})
-
 const toEscape = [
   '\u0000', // NUL  Null character
   '\u0001', // SOH  Start of Heading

package/node_modules/pino/test/fixtures/ts/transpile.cjs

@@ -7,7 +7,7 @@ const existsSync = fs.existsSync
 const stat = fs.promises.stat
 
 // Hardcoded parameters
-const esVersions = ['es6', 'es2017', 'esnext']
+const esVersions = ['es5', 'es6', 'es2017', 'esnext']
 const filesToTranspile = ['to-file-transport.ts']
 
 async function transpile () {
@@ -23,8 +23,8 @@ async function transpile () {
       const shouldTranspile = !existsSync(targetFileName) || (await stat(targetFileName)).mtimeMs < sourceStat.mtimeMs
 
       if (shouldTranspile) {
-        await execa('tsc', [ '--ignoreConfig', '--types', 'node', '--target', esVersion, '--module', 'commonjs', sourceFileName ])
-        await execa('mv', [ intermediateFileName, targetFileName ])
+        await execa('tsc', ['--target', esVersion, '--module', 'commonjs', sourceFileName])
+        await execa('mv', [intermediateFileName, targetFileName])
       }
     }
   }

package/node_modules/pino/test/helper.js

@@ -88,18 +88,14 @@ function watchForWrite (filename, testString) {
     const threshold = TIMEOUT / INTERVAL
     let counter = 0
     const interval = setInterval(() => {
-      const exists = existsSync(filename)
-      if (exists && readFileSync(filename).includes(testString)) {
+      if (readFileSync(filename).includes(testString)) {
         clearInterval(interval)
         resolve()
       } else if (counter <= threshold) {
         counter++
       } else {
         clearInterval(interval)
-        reject(new Error(
-          `'${testString}' hasn't been written to ${filename} within ${TIMEOUT} ms. ` +
-          (exists ? 'File exists, but content is still incomplete.' : 'File not yet created.')
-        ))
+        reject(new Error(`'${testString}' hasn't been written to ${filename} within ${TIMEOUT} ms.`))
       }
     }, INTERVAL)
   })

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

@@ -414,40 +414,6 @@ 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) {
@@ -712,36 +678,6 @@ 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,33 +891,3 @@ 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/transport/core.test.js

@@ -267,59 +267,6 @@ 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()
@@ -549,38 +496,6 @@ 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,7 +6,6 @@ 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')
@@ -48,14 +47,6 @@ 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)
@@ -73,7 +64,4 @@ 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 { watchForWrite, file } = require('../helper')
+const { watchFileCreated, 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 watchForWrite(destination, '"body":"bar"')
+  await watchFileCreated(destination)
   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 watchForWrite(destination, '"body":"qux"')
+  await watchFileCreated(destination)
   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 watchForWrite(destination, '"body":"buzz"')
+  await watchFileCreated(destination)
   const result = parseLogs(await readFile(destination))
 
   assert.deepEqual(result, [{

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

@@ -0,0 +1,30 @@
+import { expectType } from "tsd";
+
+import * as pinoStar from "../../pino";
+import { default as P, default as pino, pino as pinoNamed } from '../../pino';
+import pinoCjsImport = require ("../../pino");
+const pinoCjs = require("../../pino");
+const { P: pinoCjsNamed } = require('pino')
+
+const log = pino();
+expectType<P.LogFn>(log.info);
+expectType<P.LogFn>(log.error);
+
+expectType<pino.Logger>(pinoNamed());
+expectType<P.Logger>(pinoNamed());
+expectType<pino.Logger>(pinoStar.default());
+expectType<pino.Logger>(pinoStar.pino());
+// expectType<pino.Logger>(pinoCjsImport.default());
+expectType<pino.Logger>(pinoCjsImport.pino());
+expectType<any>(pinoCjsNamed());
+expectType<any>(pinoCjs());
+expectType<P.TimeFn>(pinoNamed.stdTimeFunctions.isoTimeNano)
+expectType<string>(pinoNamed.stdTimeFunctions.isoTimeNano())
+
+const levelChangeEventListener: P.LevelChangeEventListener = (
+    lvl: P.LevelWithSilent | string,
+    val: number,
+    prevLvl: P.LevelWithSilent | string,
+    prevVal: number,
+) => {}
+expectType<P.LevelChangeEventListener>(levelChangeEventListener)

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

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

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

@@ -0,0 +1,34 @@
+import { expectType, expectAssignable } from 'tsd'
+import type { SonicBoom } from 'sonic-boom'
+
+import pino, {
+  destination,
+  type LevelMapping,
+  levels,
+  type Logger,
+  multistream,
+  type MultiStreamRes,
+  type SerializedError,
+  stdSerializers,
+  stdTimeFunctions,
+  symbols,
+  transport,
+  version,
+} from '../../pino'
+
+expectType<SonicBoom>(destination(''))
+expectType<LevelMapping>(levels)
+expectType<MultiStreamRes>(multistream(process.stdout))
+expectType<SerializedError>(stdSerializers.err({} as any))
+expectType<string>(stdTimeFunctions.isoTime())
+expectType<string>(stdTimeFunctions.isoTimeNano())
+expectType<string>(version)
+
+// Can't test against `unique symbol`, see https://github.com/SamVerschueren/tsd/issues/49
+expectAssignable<Symbol>(symbols.endSym)
+
+// TODO: currently returns (aliased) `any`, waiting for strong typed `thread-stream`
+transport({
+  target: '#pino/pretty',
+  options: { some: 'options for', the: 'transport' }
+})