@wbce/projen-d9 0.0.27 → 0.1.0

package/node_modules/pino/test/complex-objects.test.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { PassThrough } = require('node:stream')
+
+const { sink, once } = require('./helper')
+const pino = require('../')
+
+test('Proxy and stream objects', async () => {
+  const s = new PassThrough()
+  s.resume()
+  s.write('', () => {})
+  const obj = { s, p: new Proxy({}, { get () { throw new Error('kaboom') } }) }
+  const stream = sink()
+  const instance = pino(stream)
+  instance.info({ obj })
+
+  const result = await once(stream, 'data')
+
+  assert.equal(result.obj, '[unable to serialize, circular reference is too complex to analyze]')
+})
+
+test('Proxy and stream objects', async () => {
+  const s = new PassThrough()
+  s.resume()
+  s.write('', () => {})
+  const obj = { s, p: new Proxy({}, { get () { throw new Error('kaboom') } }) }
+  const stream = sink()
+  const instance = pino(stream)
+  instance.info(obj)
+
+  const result = await once(stream, 'data')
+
+  assert.equal(result.p, '[unable to serialize, circular reference is too complex to analyze]')
+})

package/node_modules/pino/test/crlf.test.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+
+const writer = require('flush-write-stream')
+const pino = require('../')
+
+function capture () {
+  const ws = writer((chunk, enc, cb) => {
+    ws.data += chunk.toString()
+    cb()
+  })
+  ws.data = ''
+  return ws
+}
+
+test('pino uses LF by default', async () => {
+  const stream = capture()
+  const logger = pino(stream)
+  logger.info('foo')
+  logger.error('bar')
+  assert.ok(/foo[^\r\n]+\n[^\r\n]+bar[^\r\n]+\n/.test(stream.data))
+})
+
+test('pino can log CRLF', async () => {
+  const stream = capture()
+  const logger = pino({
+    crlf: true
+  }, stream)
+  logger.info('foo')
+  logger.error('bar')
+  assert.ok(/foo[^\n]+\r\n[^\n]+bar[^\n]+\r\n/.test(stream.data))
+})

package/node_modules/pino/test/custom-levels.test.js

@@ -0,0 +1,267 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const test = require('node:test')
+const assert = require('node:assert')
+
+const { sink, once } = require('./helper')
+const pino = require('../')
+
+// Silence all warnings for this test
+process.removeAllListeners('warning')
+process.on('warning', () => {})
+
+test('adds additional levels', async () => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35,
+      bar: 45
+    }
+  }, stream)
+
+  logger.foo('test')
+  const { level } = await once(stream, 'data')
+  assert.equal(level, 35)
+})
+
+test('custom levels does not override default levels', async () => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35
+    }
+  }, stream)
+
+  logger.info('test')
+  const { level } = await once(stream, 'data')
+  assert.equal(level, 30)
+})
+
+test('default levels can be redefined using custom levels', async () => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      info: 35,
+      debug: 45
+    },
+    useOnlyCustomLevels: true
+  }, stream)
+
+  assert.equal(logger.hasOwnProperty('info'), true)
+
+  logger.info('test')
+  const { level } = await once(stream, 'data')
+  assert.equal(level, 35)
+})
+
+test('custom levels overrides default level label if use useOnlyCustomLevels', async () => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35
+    },
+    useOnlyCustomLevels: true,
+    level: 'foo'
+  }, stream)
+
+  assert.equal(logger.hasOwnProperty('info'), false)
+})
+
+test('custom levels overrides default level value if use useOnlyCustomLevels', async () => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35
+    },
+    useOnlyCustomLevels: true,
+    level: 35
+  }, stream)
+
+  assert.equal(logger.hasOwnProperty('info'), false)
+})
+
+test('custom levels are inherited by children', async () => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35
+    }
+  }, stream)
+
+  logger.child({ childMsg: 'ok' }).foo('test')
+  const { msg, childMsg, level } = await once(stream, 'data')
+  assert.equal(level, 35)
+  assert.equal(childMsg, 'ok')
+  assert.equal(msg, 'test')
+})
+
+test('custom levels can be specified on child bindings', async () => {
+  const stream = sink()
+  const logger = pino(stream).child({
+    childMsg: 'ok'
+  }, {
+    customLevels: {
+      foo: 35
+    }
+  })
+
+  logger.foo('test')
+  const { msg, childMsg, level } = await once(stream, 'data')
+  assert.equal(level, 35)
+  assert.equal(childMsg, 'ok')
+  assert.equal(msg, 'test')
+})
+
+test('customLevels property child bindings does not get logged', async () => {
+  const stream = sink()
+  const logger = pino(stream).child({
+    childMsg: 'ok'
+  }, {
+    customLevels: {
+      foo: 35
+    }
+  })
+
+  logger.foo('test')
+  const { customLevels } = await once(stream, 'data')
+  assert.equal(customLevels, undefined)
+})
+
+test('throws when specifying pre-existing parent labels via child bindings', async () => {
+  const stream = sink()
+  assert.throws(
+    () => pino({
+      customLevels: {
+        foo: 35
+      }
+    }, stream).child({}, {
+      customLevels: {
+        foo: 45
+      }
+    }),
+    /levels cannot be overridden/
+  )
+})
+
+test('throws when specifying pre-existing parent values via child bindings', async () => {
+  const stream = sink()
+  assert.throws(
+    () => pino({
+      customLevels: {
+        foo: 35
+      }
+    }, stream).child({}, {
+      customLevels: {
+        bar: 35
+      }
+    }),
+    /pre-existing level values cannot be used for new levels/
+  )
+})
+
+test('throws when specifying core values via child bindings', async () => {
+  const stream = sink()
+  assert.throws(
+    () => pino(stream).child({}, {
+      customLevels: {
+        foo: 30
+      }
+    }),
+    /pre-existing level values cannot be used for new levels/
+  )
+})
+
+test('throws when useOnlyCustomLevels is set true without customLevels', async () => {
+  const stream = sink()
+  assert.throws(
+    () => pino({
+      useOnlyCustomLevels: true
+    }, stream),
+    /customLevels is required if useOnlyCustomLevels is set true/
+  )
+})
+
+test('custom level on one instance does not affect other instances', async () => {
+  pino({
+    customLevels: {
+      foo: 37
+    }
+  })
+  assert.equal(typeof pino().foo, 'undefined')
+})
+
+test('setting level below or at custom level will successfully log', async () => {
+  const stream = sink()
+  const instance = pino({ customLevels: { foo: 35 } }, stream)
+  instance.level = 'foo'
+  instance.info('nope')
+  instance.foo('bar')
+  const { msg } = await once(stream, 'data')
+  assert.equal(msg, 'bar')
+})
+
+test('custom level below level threshold will not log', async () => {
+  const stream = sink()
+  const instance = pino({ customLevels: { foo: 15 } }, stream)
+  instance.level = 'info'
+  instance.info('bar')
+  instance.foo('nope')
+  const { msg } = await once(stream, 'data')
+  assert.equal(msg, 'bar')
+})
+
+test('does not share custom level state across siblings', async () => {
+  const stream = sink()
+  const logger = pino(stream)
+  logger.child({}, {
+    customLevels: { foo: 35 }
+  })
+  assert.doesNotThrow(() => {
+    logger.child({}, {
+      customLevels: { foo: 35 }
+    })
+  })
+})
+
+test('custom level does not affect the levels serializer', async () => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35,
+      bar: 45
+    },
+    formatters: {
+      level (label, number) {
+        return { priority: number }
+      }
+    }
+  }, stream)
+
+  logger.foo('test')
+  const { priority } = await once(stream, 'data')
+  assert.equal(priority, 35)
+})
+
+test('When useOnlyCustomLevels is set to true, the level formatter should only get custom levels', async () => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      answer: 42
+    },
+    useOnlyCustomLevels: true,
+    level: 42,
+    formatters: {
+      level (label, number) {
+        assert.equal(label, 'answer')
+        assert.equal(number, 42)
+        return { level: number }
+      }
+    }
+  }, stream)
+
+  logger.answer('test')
+  const { level } = await once(stream, 'data')
+  assert.equal(level, 42)
+})

package/node_modules/pino/test/diagnostics.test.js

@@ -0,0 +1,107 @@
+'use strict'
+
+const test = require('node:test')
+const os = require('node:os')
+const diagChan = require('node:diagnostics_channel')
+const { AsyncLocalStorage } = require('node:async_hooks')
+const { Writable } = require('node:stream')
+const tspl = require('@matteo.collina/tspl')
+const pino = require('../pino')
+
+const hostname = os.hostname()
+const { pid } = process
+const AS_JSON_START = 'tracing:pino_asJson:start'
+const AS_JSON_END = 'tracing:pino_asJson:end'
+
+// Skip tests if diagnostics_channel.tracingChannel is not available (Node < 18.19)
+const skip = typeof diagChan.tracingChannel !== 'function'
+
+test.beforeEach(ctx => {
+  ctx.pino = {
+    ts: 1757512800000, // 2025-09-10T10:00:00.000-05:00
+    now: Date.now
+  }
+
+  Date.now = () => ctx.pino.ts
+
+  ctx.pino.dest = new Writable({
+    objectMode: true,
+    write (data, enc, cb) {
+      cb()
+    }
+  })
+})
+
+test.afterEach(ctx => {
+  Date.now = ctx.pino.now
+})
+
+test('asJson emits events', { skip }, async (t) => {
+  const plan = tspl(t, { plan: 8 })
+  const { dest } = t.pino
+  const logger = pino({}, dest)
+  const expectedArguments = [
+    {},
+    'testing',
+    30,
+    `,"time":${t.pino.ts}`
+  ]
+
+  let startEvent
+  diagChan.subscribe(AS_JSON_START, startHandler)
+  diagChan.subscribe(AS_JSON_END, endHandler)
+
+  logger.info('testing')
+  await plan
+
+  diagChan.unsubscribe(AS_JSON_START, startHandler)
+  diagChan.unsubscribe(AS_JSON_END, endHandler)
+
+  function startHandler (event) {
+    startEvent = event
+    plan.equal(Object.prototype.toString.call(event.instance), '[object Pino]')
+    plan.equal(event.instance === logger, true)
+    plan.deepStrictEqual(Array.from(event.arguments ?? []), expectedArguments)
+  }
+
+  function endHandler (event) {
+    plan.equal(Object.prototype.toString.call(event.instance), '[object Pino]')
+    plan.equal(event.instance === logger, true)
+    plan.deepStrictEqual(Array.from(event.arguments ?? []), expectedArguments)
+    plan.equal(
+      event.result,
+      `{"level":30,"time":${t.pino.ts},"pid":${pid},"hostname":"${hostname}","msg":"testing"}\n`
+    )
+
+    plan.equal(event.arguments === startEvent.arguments, true, 'same event object is supplied to both events')
+  }
+})
+
+test('asJson context is not lost', { skip }, async (t) => {
+  const plan = tspl(t, { plan: 2 })
+  const { dest } = t.pino
+  const logger = pino({}, dest)
+  const asyncLocalStorage = new AsyncLocalStorage()
+  const localStore = { foo: 'bar' }
+
+  diagChan.subscribe(AS_JSON_START, startHandler)
+  diagChan.subscribe(AS_JSON_END, endHandler)
+
+  asyncLocalStorage.run(localStore, () => {
+    logger.info('testing')
+  })
+  await plan
+
+  diagChan.unsubscribe(AS_JSON_START, startHandler)
+  diagChan.unsubscribe(AS_JSON_END, endHandler)
+
+  function startHandler () {
+    const store = asyncLocalStorage.getStore()
+    plan.equal(store === localStore, true)
+  }
+
+  function endHandler () {
+    const store = asyncLocalStorage.getStore()
+    plan.equal(store === localStore, true)
+  }
+})

package/node_modules/pino/test/error-key.test.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+
+const { sink, once } = require('./helper')
+const stdSerializers = require('pino-std-serializers')
+const pino = require('../')
+
+test('set the errorKey with error serializer', async () => {
+  const stream = sink()
+  const errorKey = 'error'
+  const instance = pino({
+    errorKey,
+    serializers: { [errorKey]: stdSerializers.err }
+  }, stream)
+  instance.error(new ReferenceError('test'))
+  const o = await once(stream, 'data')
+  assert.equal(typeof o[errorKey], 'object')
+  assert.equal(o[errorKey].type, 'ReferenceError')
+  assert.equal(o[errorKey].message, 'test')
+  assert.equal(typeof o[errorKey].stack, 'string')
+})
+
+test('set the errorKey without error serializer', async () => {
+  const stream = sink()
+  const errorKey = 'error'
+  const instance = pino({
+    errorKey
+  }, stream)
+  instance.error(new ReferenceError('test'))
+  const o = await once(stream, 'data')
+  assert.equal(typeof o[errorKey], 'object')
+  assert.equal(o[errorKey].type, 'ReferenceError')
+  assert.equal(o[errorKey].message, 'test')
+  assert.equal(typeof o[errorKey].stack, 'string')
+})