@wbce/projen-d9 0.0.28 → 0.1.0

package/node_modules/pino/test/fixtures/ts/to-file-transport.ts

@@ -0,0 +1,11 @@
+import * as fs from 'node:fs'
+import { once } from 'node:events'
+
+async function run (opts: { destination?: fs.PathLike }): Promise<fs.WriteStream> {
+  if (!opts.destination) throw new Error('kaboom')
+  const stream = fs.createWriteStream(opts.destination, { encoding: 'utf8' })
+  await once(stream, 'open')
+  return stream
+}
+
+export default run

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

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+const execa = require('execa')
+const fs = require('node:fs')
+
+const existsSync = fs.existsSync
+const stat = fs.promises.stat
+
+// Hardcoded parameters
+const esVersions = ['es6', 'es2017', 'esnext']
+const filesToTranspile = ['to-file-transport.ts']
+
+async function transpile () {
+  process.chdir(__dirname)
+
+  for (const sourceFileName of filesToTranspile) {
+    const sourceStat = await stat(sourceFileName)
+
+    for (const esVersion of esVersions) {
+      const intermediateFileName = sourceFileName.replace(/\.ts$/, '.js')
+      const targetFileName = sourceFileName.replace(/\.ts$/, `.${esVersion}.cjs`)
+
+      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 ])
+      }
+    }
+  }
+}
+
+transpile().catch(err => {
+  process.exitCode = 1
+  throw err
+})

package/node_modules/pino/test/fixtures/ts/transport-exit-immediately-with-async-dest.ts

@@ -0,0 +1,15 @@
+import pino from '../../..'
+import { join } from 'node:path'
+
+const transport = pino.transport({
+  target: join(__dirname, 'to-file-transport-with-transform.ts'),
+  options: {
+    destination: process.argv[2]
+  }
+})
+const logger = pino(transport)
+
+logger.info('Hello')
+logger.info('World')
+
+process.exit(0)

package/node_modules/pino/test/fixtures/ts/transport-exit-immediately.ts

@@ -0,0 +1,10 @@
+import pino from '../../..'
+
+const transport = pino.transport({
+  target: 'pino/file'
+})
+const logger = pino(transport)
+
+logger.info('Hello')
+
+process.exit(0)

package/node_modules/pino/test/fixtures/ts/transport-exit-on-ready.ts

@@ -0,0 +1,11 @@
+import pino from '../../..'
+
+const transport = pino.transport({
+  target: 'pino/file'
+})
+const logger = pino(transport)
+
+transport.on('ready', function () {
+  logger.info('Hello')
+  process.exit(0)
+})

package/node_modules/pino/test/fixtures/ts/transport-main.ts

@@ -0,0 +1,8 @@
+import { join } from 'node:path'
+import pino from '../../..'
+
+const transport = pino.transport({
+  target: join(__dirname, 'transport-worker.ts')
+})
+const logger = pino(transport)
+logger.info('Hello')

package/node_modules/pino/test/fixtures/ts/transport-string-stdout.ts

@@ -0,0 +1,8 @@
+import pino from '../../..'
+
+const transport = pino.transport({
+  target: 'pino/file',
+  options: { destination: '1' }
+})
+const logger = pino(transport)
+logger.info('Hello')

package/node_modules/pino/test/fixtures/ts/transport-worker.ts

@@ -0,0 +1,14 @@
+import { Writable } from 'node:stream'
+
+export default (): Writable => {
+  const myTransportStream = new Writable({
+    autoDestroy: true,
+    write (chunk, _enc, cb) {
+      console.log(chunk.toString())
+      cb()
+    },
+    defaultEncoding: 'utf8'
+  })
+
+  return myTransportStream
+}

package/node_modules/pino/test/formatters.test.js

@@ -0,0 +1,364 @@
+'use strict'
+/* eslint no-prototype-builtins: 0 */
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { hostname } = require('node:os')
+const { join } = require('node:path')
+const { readFile } = require('node:fs').promises
+const tspl = require('@matteo.collina/tspl')
+
+const { sink, match, once, watchFileCreated, file } = require('./helper')
+const pino = require('../')
+
+test('level formatter', async () => {
+  const stream = sink()
+  const logger = pino({
+    formatters: {
+      level (label, number) {
+        return {
+          log: {
+            level: label
+          }
+        }
+      }
+    }
+  }, stream)
+
+  const o = once(stream, 'data')
+  logger.info('hello world')
+  match(await o, {
+    log: {
+      level: 'info'
+    }
+  })
+})
+
+test('bindings formatter', async () => {
+  const stream = sink()
+  const logger = pino({
+    formatters: {
+      bindings (bindings) {
+        return {
+          process: {
+            pid: bindings.pid
+          },
+          host: {
+            name: bindings.hostname
+          }
+        }
+      }
+    }
+  }, stream)
+
+  const o = once(stream, 'data')
+  logger.info('hello world')
+  match(await o, {
+    process: {
+      pid: process.pid
+    },
+    host: {
+      name: hostname()
+    }
+  })
+})
+
+test('no bindings formatter', async () => {
+  const stream = sink()
+  const logger = pino({
+    formatters: {
+      bindings (bindings) {
+        return null
+      }
+    }
+  }, stream)
+
+  const o = once(stream, 'data')
+  logger.info('hello world')
+  const log = await o
+  assert.equal(log.hasOwnProperty('pid'), false)
+  assert.equal(log.hasOwnProperty('hostname'), false)
+  match(log, { msg: 'hello world' })
+})
+
+test('log formatter', async (t) => {
+  const plan = tspl(t, { plan: 1 })
+  const stream = sink()
+  const logger = pino({
+    formatters: {
+      log (obj) {
+        plan.equal(obj.hasOwnProperty('msg'), false)
+        return { hello: 'world', ...obj }
+      }
+    }
+  }, stream)
+
+  const o = once(stream, 'data')
+  logger.info({ foo: 'bar', nested: { object: true } }, 'hello world')
+  match(await o, {
+    hello: 'world',
+    foo: 'bar',
+    nested: { object: true }
+  })
+
+  await plan
+})
+
+test('Formatters combined', async () => {
+  const stream = sink()
+  const logger = pino({
+    formatters: {
+      level (label, number) {
+        return {
+          log: {
+            level: label
+          }
+        }
+      },
+      bindings (bindings) {
+        return {
+          process: {
+            pid: bindings.pid
+          },
+          host: {
+            name: bindings.hostname
+          }
+        }
+      },
+      log (obj) {
+        return { hello: 'world', ...obj }
+      }
+    }
+  }, stream)
+
+  const o = once(stream, 'data')
+  logger.info({ foo: 'bar', nested: { object: true } }, 'hello world')
+  match(await o, {
+    log: {
+      level: 'info'
+    },
+    process: {
+      pid: process.pid
+    },
+    host: {
+      name: hostname()
+    },
+    hello: 'world',
+    foo: 'bar',
+    nested: { object: true }
+  })
+})
+
+test('Formatters in child logger', async () => {
+  const stream = sink()
+  const logger = pino({
+    formatters: {
+      level (label, number) {
+        return {
+          log: {
+            level: label
+          }
+        }
+      },
+      bindings (bindings) {
+        return {
+          process: {
+            pid: bindings.pid
+          },
+          host: {
+            name: bindings.hostname
+          }
+        }
+      },
+      log (obj) {
+        return { hello: 'world', ...obj }
+      }
+    }
+  }, stream)
+
+  const child = logger.child({
+    foo: 'bar',
+    nested: { object: true }
+  }, {
+    formatters: {
+      bindings (bindings) {
+        return { ...bindings, faz: 'baz' }
+      }
+    }
+  })
+
+  const o = once(stream, 'data')
+  child.info('hello world')
+  match(await o, {
+    log: {
+      level: 'info'
+    },
+    process: {
+      pid: process.pid
+    },
+    host: {
+      name: hostname()
+    },
+    hello: 'world',
+    foo: 'bar',
+    nested: { object: true },
+    faz: 'baz'
+  })
+})
+
+test('Formatters without bindings in child logger', async () => {
+  const stream = sink()
+  const logger = pino({
+    formatters: {
+      level (label, number) {
+        return {
+          log: {
+            level: label
+          }
+        }
+      },
+      bindings (bindings) {
+        return {
+          process: {
+            pid: bindings.pid
+          },
+          host: {
+            name: bindings.hostname
+          }
+        }
+      },
+      log (obj) {
+        return { hello: 'world', ...obj }
+      }
+    }
+  }, stream)
+
+  const child = logger.child({
+    foo: 'bar',
+    nested: { object: true }
+  }, {
+    formatters: {
+      log (obj) {
+        return { other: 'stuff', ...obj }
+      }
+    }
+  })
+
+  const o = once(stream, 'data')
+  child.info('hello world')
+  match(await o, {
+    log: {
+      level: 'info'
+    },
+    process: {
+      pid: process.pid
+    },
+    host: {
+      name: hostname()
+    },
+    foo: 'bar',
+    other: 'stuff',
+    nested: { object: true }
+  })
+})
+
+test('elastic common schema format', async () => {
+  const stream = sink()
+  const ecs = {
+    formatters: {
+      level (label, number) {
+        return {
+          log: {
+            level: label,
+            logger: 'pino'
+          }
+        }
+      },
+      bindings (bindings) {
+        return {
+          process: {
+            pid: bindings.pid
+          },
+          host: {
+            name: bindings.hostname
+          }
+        }
+      },
+      log (obj) {
+        return { ecs: { version: '1.4.0' }, ...obj }
+      }
+    },
+    messageKey: 'message',
+    timestamp: () => `,"@timestamp":"${new Date(Date.now()).toISOString()}"`
+  }
+
+  const logger = pino({ ...ecs }, stream)
+
+  const o = once(stream, 'data')
+  logger.info({ foo: 'bar' }, 'hello world')
+  const log = await o
+  assert.equal(typeof log['@timestamp'], 'string')
+  match(log, {
+    log: { level: 'info', logger: 'pino' },
+    process: { pid: process.pid },
+    host: { name: hostname() },
+    ecs: { version: '1.4.0' },
+    foo: 'bar',
+    message: 'hello world'
+  })
+})
+
+test('formatter with transport', async (t) => {
+  const plan = tspl(t, { plan: 1 })
+  const destination = file()
+  const logger = pino({
+    formatters: {
+      log (obj) {
+        plan.equal(obj.hasOwnProperty('msg'), false)
+        return { hello: 'world', ...obj }
+      }
+    },
+    transport: {
+      targets: [
+        {
+          target: join(__dirname, 'fixtures', 'to-file-transport.js'),
+          options: { destination }
+        }
+      ]
+    }
+  })
+
+  logger.info({ foo: 'bar', nested: { object: true } }, 'hello world')
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination))
+  delete result.time
+  match(result, {
+    hello: 'world',
+    foo: 'bar',
+    nested: { object: true }
+  })
+})
+
+test('throws when custom level formatter is used with transport.targets', async () => {
+  assert.throws(
+    () => {
+      pino({
+        formatters: {
+          level (label) {
+            return label
+          }
+        },
+        transport: {
+          targets: [
+            {
+              target: 'pino/file',
+              options: { destination: 'foo.log' }
+            }
+          ]
+        }
+      }
+      )
+    },
+    Error('option.transport.targets do not allow custom level formatters')
+  )
+})

package/node_modules/pino/test/helper.d.ts

@@ -0,0 +1,4 @@
+import type { PathLike } from 'node:fs'
+
+export declare function watchFileCreated (filename: PathLike): Promise<void>
+export declare function watchForWrite (filename: PathLike, testString: string): Promise<void>

package/node_modules/pino/test/helper.js

@@ -0,0 +1,159 @@
+'use strict'
+
+const crypto = require('node:crypto')
+const { join } = require('node:path')
+const os = require('node:os')
+const { existsSync, readFileSync, statSync, unlinkSync } = require('node:fs')
+const writer = require('flush-write-stream')
+const split = require('split2')
+
+const pid = process.pid
+const hostname = os.hostname()
+const { tmpdir } = os
+
+const isWin = process.platform === 'win32'
+const isYarnPnp = process.versions.pnp !== undefined
+
+function getPathToNull () {
+  return isWin ? '\\\\.\\NUL' : '/dev/null'
+}
+
+function once (emitter, name) {
+  return new Promise((resolve, reject) => {
+    if (name !== 'error') emitter.once('error', reject)
+    emitter.once(name, (...args) => {
+      emitter.removeListener('error', reject)
+      resolve(...args)
+    })
+  })
+}
+
+function sink (func) {
+  const result = split((data) => {
+    try {
+      return JSON.parse(data)
+    } catch (err) {
+      console.log(err)
+      console.log(data)
+    }
+  })
+  if (func) result.pipe(writer.obj(func))
+  return result
+}
+
+function check (is, chunk, level, msg) {
+  is(new Date(chunk.time) <= new Date(), true, 'time is greater than Date.now()')
+  delete chunk.time
+  is(chunk.pid, pid)
+  is(chunk.hostname, hostname)
+  is(chunk.level, level)
+  is(chunk.msg, msg)
+}
+
+function sleep (ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms)
+  })
+}
+
+function watchFileCreated (filename) {
+  return new Promise((resolve, reject) => {
+    const TIMEOUT = process.env.PINO_TEST_WAIT_WATCHFILE_TIMEOUT || 10000
+    const INTERVAL = 100
+    const threshold = TIMEOUT / INTERVAL
+    let counter = 0
+    const interval = setInterval(() => {
+      const exists = existsSync(filename)
+      // On some CI runs file is created but not filled
+      if (exists && statSync(filename).size !== 0) {
+        clearInterval(interval)
+        resolve()
+      } else if (counter <= threshold) {
+        counter++
+      } else {
+        clearInterval(interval)
+        reject(new Error(
+          `${filename} hasn't been created within ${TIMEOUT} ms. ` +
+          (exists ? 'File exist, but still empty.' : 'File not yet created.')
+        ))
+      }
+    }, INTERVAL)
+  })
+}
+
+function watchForWrite (filename, testString) {
+  return new Promise((resolve, reject) => {
+    const TIMEOUT = process.env.PINO_TEST_WAIT_WRITE_TIMEOUT || 10000
+    const INTERVAL = 100
+    const threshold = TIMEOUT / INTERVAL
+    let counter = 0
+    const interval = setInterval(() => {
+      const exists = existsSync(filename)
+      if (exists && 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.')
+        ))
+      }
+    }, INTERVAL)
+  })
+}
+
+let files = []
+
+function file () {
+  const hash = crypto.randomBytes(12).toString('hex')
+  const file = join(tmpdir(), `pino-${pid}-${hash}`)
+  files.push(file)
+  return file
+}
+
+process.on('beforeExit', () => {
+  if (files.length === 0) return
+  for (const file of files) {
+    try {
+      unlinkSync(file)
+    } catch (e) {
+    }
+  }
+  files = []
+})
+
+/**
+ * match is a bare-bones object shape matcher. We should be able to replace
+ * this with `assert.partialDeepStrictEqual` when v22 is our minimum.
+ *
+ * @param {object} found
+ * @param {object} expected
+ */
+function match (found, expected) {
+  for (const [key, value] of Object.entries(expected)) {
+    if (Object.prototype.toString.call(value) === '[object Object]') {
+      match(found[key], value)
+      continue
+    }
+    if (value !== found[key]) {
+      throw Error(`expected "${value}" but found "${found[key]}"`)
+    }
+  }
+}
+
+module.exports = {
+  check,
+  file,
+  getPathToNull,
+  isWin,
+  isYarnPnp,
+  match,
+  once,
+  sink,
+  sleep,
+  watchFileCreated,
+  watchForWrite
+}