@wbce/projen-d9 0.0.28 → 0.1.0

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

@@ -0,0 +1,137 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const os = require('node:os')
+const { join } = require('node:path')
+const { readFile } = require('node:fs').promises
+
+const { watchFileCreated, file } = require('../helper')
+const pino = require('../../')
+const { DEFAULT_LEVELS } = require('../../lib/constants')
+
+const { pid } = process
+const hostname = os.hostname()
+
+test('pino.transport with a pipeline', async (t) => {
+  const destination = file()
+  const transport = pino.transport({
+    pipeline: [{
+      target: join(__dirname, '..', 'fixtures', 'transport-transform.js')
+    }, {
+      target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
+      options: { destination }
+    }]
+  })
+  t.after(transport.end.bind(transport))
+  const instance = pino(transport)
+  instance.info('hello')
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination))
+  delete result.time
+  assert.deepEqual(result, {
+    pid,
+    hostname,
+    level: DEFAULT_LEVELS.info,
+    msg: 'hello',
+    service: 'pino' // this property was added by the transform
+  })
+})
+
+test('pino.transport with targets containing pipelines', async (t) => {
+  const destinationA = file()
+  const destinationB = file()
+  const transport = pino.transport({
+    targets: [
+      {
+        target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
+        options: { destination: destinationA }
+      },
+      {
+        pipeline: [
+          {
+            target: join(__dirname, '..', 'fixtures', 'transport-transform.js')
+          },
+          {
+            target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
+            options: { destination: destinationB }
+          }
+        ]
+      }
+    ]
+  })
+
+  t.after(transport.end.bind(transport))
+  const instance = pino(transport)
+  instance.info('hello')
+  await watchFileCreated(destinationA)
+  await watchFileCreated(destinationB)
+  const resultA = JSON.parse(await readFile(destinationA))
+  const resultB = JSON.parse(await readFile(destinationB))
+  delete resultA.time
+  delete resultB.time
+  assert.deepEqual(resultA, {
+    pid,
+    hostname,
+    level: DEFAULT_LEVELS.info,
+    msg: 'hello'
+  })
+  assert.deepEqual(resultB, {
+    pid,
+    hostname,
+    level: DEFAULT_LEVELS.info,
+    msg: 'hello',
+    service: 'pino' // this property was added by the transform
+  })
+})
+
+test('pino.transport with targets containing pipelines with levels defined and dedupe', async (t) => {
+  const destinationA = file()
+  const destinationB = file()
+  const transport = pino.transport({
+    targets: [
+      {
+        target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
+        options: { destination: destinationA },
+        level: DEFAULT_LEVELS.info
+      },
+      {
+        pipeline: [
+          {
+            target: join(__dirname, '..', 'fixtures', 'transport-transform.js')
+          },
+          {
+            target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
+            options: { destination: destinationB }
+          }
+        ],
+        level: DEFAULT_LEVELS.error
+      }
+    ],
+    dedupe: true
+  })
+
+  t.after(transport.end.bind(transport))
+  const instance = pino(transport)
+  instance.info('hello info')
+  instance.error('hello error')
+  await watchFileCreated(destinationA)
+  await watchFileCreated(destinationB)
+  const resultA = JSON.parse(await readFile(destinationA))
+  const resultB = JSON.parse(await readFile(destinationB))
+  delete resultA.time
+  delete resultB.time
+  assert.deepEqual(resultA, {
+    pid,
+    hostname,
+    level: DEFAULT_LEVELS.info,
+    msg: 'hello info'
+  })
+  assert.deepEqual(resultB, {
+    pid,
+    hostname,
+    level: DEFAULT_LEVELS.error,
+    msg: 'hello error',
+    service: 'pino' // this property was added by the transform
+  })
+})

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

@@ -0,0 +1,54 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { join } = require('node:path')
+const { pathToFileURL } = require('node:url')
+const { readFile } = require('node:fs').promises
+const execa = require('execa')
+
+const { file, watchFileCreated } = require('../helper')
+
+test('pino.transport works when loaded via --import=preload', async () => {
+  const destination = file()
+  const preload = pathToFileURL(join(__dirname, '..', 'fixtures', 'transport-preload.mjs')).href
+  const main = join(__dirname, '..', 'fixtures', 'transport-preload-main.mjs')
+
+  await execa(process.argv[0], [
+    `--import=${preload}`,
+    main,
+    destination
+  ], { timeout: 10000 })
+
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination))
+  assert.equal(result.msg, 'hello from main')
+})
+
+test('pino.transport works when loaded via --import preload (space separated)', async () => {
+  const destination = file()
+  const preload = pathToFileURL(join(__dirname, '..', 'fixtures', 'transport-preload.mjs')).href
+  const main = join(__dirname, '..', 'fixtures', 'transport-preload-main.mjs')
+
+  await execa(process.argv[0], [
+    '--import',
+    preload,
+    main,
+    destination
+  ], { timeout: 10000 })
+
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination))
+  assert.equal(result.msg, 'hello from main')
+})
+
+test('pino.transport ignores missing absolute preload from NODE_OPTIONS in worker', async () => {
+  const destination = file()
+  const main = join(__dirname, '..', 'fixtures', 'transport-invalid-node-options.js')
+
+  await execa(process.argv[0], [main, destination], { timeout: 10000 })
+
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination))
+  assert.equal(result.msg, 'hello with invalid node options preload')
+})

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

@@ -0,0 +1,15 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const proxyquire = require('proxyquire')
+
+test('pino.transport resolves targets in REPL', async () => {
+  // Arrange
+  const transport = proxyquire('../../lib/transport', {
+    './caller': () => ['node:repl']
+  })
+
+  // Act / Assert
+  assert.doesNotThrow(() => transport({ target: 'pino-pretty' }))
+})

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

@@ -0,0 +1,79 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+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')
+
+const { pid } = process
+const hostname = os.hostname()
+
+test('thread-stream async flush', async () => {
+  const destination = file()
+  const transport = pino.transport({
+    target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
+    options: { destination }
+  })
+  const instance = pino(transport)
+  instance.info('hello')
+
+  assert.equal(instance.flush(), undefined)
+
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination))
+  delete result.time
+  assert.deepEqual(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+test('thread-stream async flush should call the passed callback', async () => {
+  const outputPath = file()
+  async function getOutputLogLines () {
+    return (await readFile(outputPath)).toString().trim().split('\n').map(JSON.parse)
+  }
+  const transport = pino.transport({
+    target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
+    options: { destination: outputPath }
+  })
+  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)
+
+  const [firstFlushData] = await getOutputLogLines()
+
+  assert.equal(firstFlushData.msg, 'hello')
+
+  instance.info('world')
+
+  await flushPromise()
+  await watchForWrite(outputPath, 'world')
+
+  // After flush, both messages should be present
+  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/sync-true.test.js

@@ -0,0 +1,57 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { join } = require('node:path')
+const { readFileSync } = require('node:fs')
+
+const { file } = require('../helper')
+const pino = require('../..')
+
+test('thread-stream sync true should log synchronously', async () => {
+  const outputPath = file()
+
+  function getOutputLogLines () {
+    return (readFileSync(outputPath)).toString().trim().split('\n').map(JSON.parse)
+  }
+
+  const transport = pino.transport({
+    target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
+    options: { destination: outputPath, flush: true },
+    sync: true
+  })
+  const instance = pino(transport)
+
+  var value = { message: 'sync' }
+  instance.info(value)
+  instance.info(value)
+  instance.info(value)
+  instance.info(value)
+  instance.info(value)
+  instance.info(value)
+  let interrupt = false
+  let flushData
+  let loopCounter = 0
+
+  // Start a synchronous loop
+  while (!interrupt && loopCounter < (process.env.MAX_TEST_LOOP_ITERATION || 20000)) {
+    try {
+      loopCounter++
+      const data = getOutputLogLines()
+      flushData = data
+      if (data) {
+        interrupt = true
+        break
+      }
+    } catch (error) {
+      // File may not exist yet
+      // Wait till MAX_TEST_LOOP_ITERATION iterations
+    }
+  }
+
+  if (!interrupt) {
+    throw new Error('Sync loop did not get interrupt')
+  }
+
+  assert.equal(flushData.length, 6)
+})

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

@@ -0,0 +1,48 @@
+'use strict'
+
+const test = require('node:test')
+const { join } = require('node:path')
+const Writable = require('node:stream').Writable
+const proxyquire = require('proxyquire')
+const tspl = require('@matteo.collina/tspl')
+const pino = require('../../pino')
+
+test('file-target mocked', async function (t) {
+  const plan = tspl(t, { plan: 1 })
+  let ret
+  const fileTarget = proxyquire('../../file', {
+    './pino': {
+      destination (opts) {
+        plan.deepEqual(opts, { dest: 1, sync: false })
+
+        ret = new Writable()
+        ret.fd = opts.dest
+
+        process.nextTick(() => {
+          ret.emit('ready')
+        })
+
+        return ret
+      }
+    }
+  })
+
+  await fileTarget()
+  await plan
+})
+
+test('pino.transport with syntax error', async (t) => {
+  const plan = tspl(t, { plan: 1 })
+  const transport = pino.transport({
+    targets: [{
+      target: join(__dirname, '..', 'fixtures', 'syntax-error-esm.mjs')
+    }]
+  })
+  t.after(transport.end.bind(transport))
+
+  transport.on('error', (err) => {
+    plan.deepEqual(err, new SyntaxError('Unexpected end of input'))
+  })
+
+  await plan
+})

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

@@ -0,0 +1,166 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const os = require('node:os')
+const { join } = require('node:path')
+const { readFile } = require('node:fs').promises
+const writeStream = require('flush-write-stream')
+
+const { watchForWrite, file } = require('../helper')
+const pino = require('../../')
+
+const { pid } = process
+const hostname = os.hostname()
+
+function serializeError (error) {
+  return {
+    type: error.name,
+    message: error.message,
+    stack: error.stack
+  }
+}
+
+function parseLogs (buffer) {
+  return JSON.parse(`[${buffer.toString().replace(/}{/g, '},{')}]`)
+}
+
+test('transport uses pino config', async (t) => {
+  const destination = file()
+  const transport = pino.transport({
+    pipeline: [{
+      target: join(__dirname, '..', 'fixtures', 'transport-uses-pino-config.js')
+    }, {
+      target: 'pino/file',
+      options: { destination }
+    }]
+  })
+  t.after(transport.end.bind(transport))
+  const instance = pino({
+    messageKey: 'customMessageKey',
+    errorKey: 'customErrorKey',
+    customLevels: { custom: 35 }
+  }, transport)
+
+  const error = new Error('bar')
+  instance.custom('foo')
+  instance.error(error)
+  await watchForWrite(destination, '"body":"bar"')
+  const result = parseLogs(await readFile(destination))
+
+  assert.deepEqual(result, [{
+    severityText: 'custom',
+    body: 'foo',
+    attributes: {
+      pid,
+      hostname
+    }
+  }, {
+    severityText: 'error',
+    body: 'bar',
+    attributes: {
+      pid,
+      hostname
+    },
+    error: serializeError(error)
+  }])
+})
+
+test('transport uses pino config without customizations', async (t) => {
+  const destination = file()
+  const transport = pino.transport({
+    pipeline: [{
+      target: join(__dirname, '..', 'fixtures', 'transport-uses-pino-config.js')
+    }, {
+      target: 'pino/file',
+      options: { destination }
+    }]
+  })
+  t.after(transport.end.bind(transport))
+  const instance = pino(transport)
+
+  const error = new Error('qux')
+  instance.info('baz')
+  instance.error(error)
+  await watchForWrite(destination, '"body":"qux"')
+  const result = parseLogs(await readFile(destination))
+
+  assert.deepEqual(result, [{
+    severityText: 'info',
+    body: 'baz',
+    attributes: {
+      pid,
+      hostname
+    }
+  }, {
+    severityText: 'error',
+    body: 'qux',
+    attributes: {
+      pid,
+      hostname
+    },
+    error: serializeError(error)
+  }])
+})
+
+test('transport uses pino config with multistream', async (t) => {
+  const destination = file()
+  const messages = []
+  const stream = writeStream(function (data, enc, cb) {
+    const message = JSON.parse(data)
+    delete message.time
+    messages.push(message)
+    cb()
+  })
+  const transport = pino.transport({
+    pipeline: [{
+      target: join(__dirname, '..', 'fixtures', 'transport-uses-pino-config.js')
+    }, {
+      target: 'pino/file',
+      options: { destination }
+    }]
+  })
+  t.after(transport.end.bind(transport))
+  const instance = pino({
+    messageKey: 'customMessageKey',
+    errorKey: 'customErrorKey',
+    customLevels: { custom: 35 }
+  }, pino.multistream([transport, { stream }]))
+
+  const error = new Error('buzz')
+  const serializedError = serializeError(error)
+  instance.custom('fizz')
+  instance.error(error)
+  await watchForWrite(destination, '"body":"buzz"')
+  const result = parseLogs(await readFile(destination))
+
+  assert.deepEqual(result, [{
+    severityText: 'custom',
+    body: 'fizz',
+    attributes: {
+      pid,
+      hostname
+    }
+  }, {
+    severityText: 'error',
+    body: 'buzz',
+    attributes: {
+      pid,
+      hostname
+    },
+    error: serializedError
+  }])
+
+  assert.deepEqual(messages, [{
+    level: 35,
+    pid,
+    hostname,
+    customMessageKey: 'fizz'
+  }, {
+    level: 50,
+    pid,
+    hostname,
+    customErrorKey: serializedError,
+    customMessageKey: 'buzz'
+  }])
+})

package/node_modules/pino/test/transport-stream.test.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const test = require('node:test')
+const proxyquire = require('proxyquire')
+const tspl = require('@matteo.collina/tspl')
+
+test('should import', async (t) => {
+  const plan = tspl(t, { plan: 2 })
+  const mockRealRequire = (target) => {
+    return {
+      default: {
+        default: () => {
+          plan.equal(target, 'pino-pretty')
+          return Promise.resolve()
+        }
+      }
+    }
+  }
+  const mockRealImport = async () => {
+    await Promise.resolve()
+    throw Object.assign(new Error(), { code: 'ERR_MODULE_NOT_FOUND' })
+  }
+
+  const loadTransportStreamBuilder = proxyquire(
+    '../lib/transport-stream.js',
+    {
+      'real-require': {
+        realRequire: mockRealRequire,
+        realImport: mockRealImport
+      }
+    }
+  )
+
+  const fn = await loadTransportStreamBuilder('pino-pretty')
+
+  await fn()
+  plan.ok('returned promise resolved')
+
+  await plan
+})

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