@wbce/projen-d9 0.0.28 → 0.1.1

package/node_modules/pino-pretty/test/boolean-options.test.js

@@ -0,0 +1,228 @@
+'use strict'
+
+process.env.TZ = 'UTC'
+
+const os = require('node:os')
+const { describe, test, beforeEach, afterEach } = require('node:test')
+const { Writable } = require('node:stream')
+const pino = require('pino')
+
+const pinoPretty = require('..')
+const _prettyFactory = pinoPretty.prettyFactory
+
+// Disable pino warnings
+process.removeAllListeners('warning')
+
+function prettyFactory (opts) {
+  if (!opts) {
+    opts = { colorize: false }
+  } else if (!Object.prototype.hasOwnProperty.call(opts, 'colorize')) {
+    opts.colorize = false
+  }
+  return _prettyFactory(opts)
+}
+
+// All dates are computed from 'Fri, 30 Mar 2018 17:35:28 GMT'
+const epoch = 1522431328992
+const formattedEpoch = '17:35:28.992'
+const pid = process.pid
+const hostname = os.hostname()
+
+describe('boolean options string conversion', () => {
+  beforeEach(() => {
+    Date.originalNow = Date.now
+    Date.now = () => epoch
+  })
+  afterEach(() => {
+    Date.now = Date.originalNow
+    delete Date.originalNow
+  })
+
+  test('accepts string "true" and "false" for all boolean options', async (t) => {
+    const logLine = `{"level":30,"time":${epoch},"msg":"foo","pid":${pid},"hostname":"${hostname}"}`
+
+    const testCases = [
+      {
+        option: 'colorize',
+        testValue: (value) => {
+          return new Promise((resolve) => {
+            const pretty = prettyFactory({ colorize: value })
+            const stream = new Writable({
+              write (chunk, enc, cb) {
+                const formatted = pretty(chunk.toString())
+                if (value === 'true') {
+                  t.assert.strictEqual(
+                    formatted,
+                    `[${formattedEpoch}] \u001B[32mINFO\u001B[39m (${pid}): \u001B[36mfoo\u001B[39m\n`
+                  )
+                } else {
+                  t.assert.strictEqual(
+                    formatted,
+                    `[${formattedEpoch}] INFO (${pid}): foo\n`
+                  )
+                }
+                cb()
+                resolve()
+              }
+            })
+            const log = pino({}, stream)
+            log.info('foo')
+          })
+        }
+      },
+      {
+        option: 'crlf',
+        testValue: (value) => {
+          return Promise.resolve().then(() => {
+            const pretty = prettyFactory({ crlf: value })
+            const formatted = pretty(logLine)
+            if (value === 'true') {
+              t.assert.strictEqual(formatted, `[${formattedEpoch}] INFO (${pid}): foo\r\n`)
+            } else {
+              t.assert.strictEqual(formatted, `[${formattedEpoch}] INFO (${pid}): foo\n`)
+            }
+          })
+        }
+      },
+      {
+        option: 'levelFirst',
+        testValue: (value) => {
+          return Promise.resolve().then(() => {
+            const pretty = prettyFactory({ levelFirst: value })
+            const formatted = pretty(logLine)
+            if (value === 'true') {
+              t.assert.strictEqual(formatted, `INFO [${formattedEpoch}] (${pid}): foo\n`)
+            } else {
+              t.assert.strictEqual(formatted, `[${formattedEpoch}] INFO (${pid}): foo\n`)
+            }
+          })
+        }
+      },
+      {
+        option: 'hideObject',
+        testValue: (value) => {
+          return new Promise((resolve) => {
+            const pretty = prettyFactory({ hideObject: value })
+            const stream = new Writable({
+              write (chunk, enc, cb) {
+                const formatted = pretty(chunk.toString())
+                if (value === 'true') {
+                  t.assert.strictEqual(formatted, `[${formattedEpoch}] INFO (${pid}): foo\n`)
+                } else {
+                  t.assert.match(formatted, /foo:\s*"bar"/)
+                }
+                cb()
+                resolve()
+              }
+            })
+            const log = pino({}, stream)
+            log.info({ foo: 'bar' }, 'foo')
+          })
+        }
+      },
+      {
+        option: 'singleLine',
+        testValue: (value) => {
+          return new Promise((resolve) => {
+            const pretty = prettyFactory({ singleLine: value })
+            const stream = new Writable({
+              write (chunk, enc, cb) {
+                const formatted = pretty(chunk.toString())
+                if (value === 'true') {
+                  t.assert.match(formatted, /{"foo":"bar"}/)
+                  t.assert.doesNotMatch(formatted, /\n\s+foo:/)
+                } else {
+                  t.assert.match(formatted, /\n\s+foo:/)
+                }
+                cb()
+                resolve()
+              }
+            })
+            const log = pino({}, stream)
+            log.info({ foo: 'bar' }, 'foo')
+          })
+        }
+      },
+      {
+        option: 'colorizeObjects',
+        testValue: (value) => {
+          return new Promise((resolve) => {
+            const pretty = prettyFactory({ colorize: true, singleLine: true, colorizeObjects: value })
+            const stream = new Writable({
+              write (chunk, enc, cb) {
+                const formatted = pretty(chunk.toString())
+                if (value === 'true') {
+                  t.assert.strictEqual(
+                    formatted,
+                    `[${formattedEpoch}] \u001B[32mINFO\u001B[39m (${pid}): \u001B[36mfoo\u001B[39m \u001B[90m{"foo":"bar"}\u001B[39m\n`
+                  )
+                } else {
+                  t.assert.strictEqual(
+                    formatted,
+                    `[${formattedEpoch}] \u001B[32mINFO\u001B[39m (${pid}): \u001B[36mfoo\u001B[39m {"foo":"bar"}\n`
+                  )
+                }
+                cb()
+                resolve()
+              }
+            })
+            const log = pino({}, stream)
+            log.info({ foo: 'bar' }, 'foo')
+          })
+        }
+      },
+      {
+        option: 'translateTime',
+        testValue: (value) => {
+          return Promise.resolve().then(() => {
+            const pretty = prettyFactory({ translateTime: value })
+            const formatted = pretty(logLine)
+            if (value === 'true') {
+              t.assert.strictEqual(formatted, `[${formattedEpoch}] INFO (${pid}): foo\n`)
+            } else {
+              t.assert.match(formatted, new RegExp(`\\[${epoch}\\] INFO \\(${pid}\\): foo\\n`))
+            }
+          })
+        }
+      },
+      {
+        option: 'useOnlyCustomProps',
+        testValue: (value) => {
+          return new Promise((resolve) => {
+            const pretty = prettyFactory({ useOnlyCustomProps: value, customLevels: 'custom:25' })
+            const stream = new Writable({
+              write (chunk, enc, cb) {
+                const formatted = pretty(chunk.toString())
+                if (value === 'true') {
+                  t.assert.match(formatted, /USERLVL/)
+                } else {
+                  t.assert.match(formatted, /INFO/)
+                }
+                cb()
+                resolve()
+              }
+            })
+            const log = pino({ customLevels: { custom: 35 } }, stream)
+            if (value === 'true') {
+              log.custom('test')
+            } else {
+              log.info('test')
+            }
+          })
+        }
+      }
+    ]
+
+    for (const testCase of testCases) {
+      await testCase.testValue('false')
+      await testCase.testValue('true')
+    }
+  })
+
+  test('translateTime still accepts format strings when not "true" or "false"', (t) => {
+    t.plan(1)
+    const pretty = prettyFactory({ translateTime: 'UTC:yyyy-mm-dd HH:MM:ss' })
+    const formatted = pretty(`{"level":30,"time":${epoch},"msg":"foo","pid":${pid},"hostname":"${hostname}"}`)
+    t.assert.match(formatted, /\[2018-03-30 17:35:28\] INFO/)
+  })
+})

package/node_modules/pino-pretty/test/cli-rc.test.js

@@ -0,0 +1,275 @@
+'use strict'
+
+process.env.TZ = 'UTC'
+
+const fs = require('node:fs')
+const path = require('node:path')
+const { spawn } = require('node:child_process')
+const { describe, after, test } = require('node:test')
+const match = require('@jsumners/assert-match')
+const { rimraf } = require('rimraf')
+const { once } = require('./helper')
+
+const bin = require.resolve('../bin')
+const logLine = '{"level":30,"time":1522431328992,"msg":"hello world","pid":42,"hostname":"foo"}\n'
+
+describe('cli', () => {
+  const tmpDir = path.join(__dirname, '.tmp_' + Date.now())
+  fs.mkdirSync(tmpDir)
+
+  after(() => rimraf(tmpDir))
+
+  test('loads and applies default config file: pino-pretty.config.js', async (t) => {
+    t.plan(1)
+    // Set translateTime: true on run configuration
+    const configFile = path.join(tmpDir, 'pino-pretty.config.js')
+    fs.writeFileSync(configFile, 'module.exports = { translateTime: true }')
+    const env = { TERM: 'dumb', TZ: 'UTC' }
+    const child = spawn(process.argv[0], [bin], { env, cwd: tmpDir })
+    // Validate that the time has been translated
+    child.on('error', t.assert.fail)
+    const endPromise = once(child.stdout, 'data', (data) => {
+      t.assert.strictEqual(data.toString(), '[17:35:28.992] INFO (42): hello world\n')
+    })
+    child.stdin.write(logLine)
+    await endPromise
+    t.after(() => {
+      fs.unlinkSync(configFile)
+      child.kill()
+    })
+  })
+
+  test('loads and applies default config file: pino-pretty.config.cjs', async (t) => {
+    t.plan(1)
+    // Set translateTime: true on run configuration
+    const configFile = path.join(tmpDir, 'pino-pretty.config.cjs')
+    fs.writeFileSync(configFile, 'module.exports = { translateTime: true }')
+    // Tell the loader to expect ESM modules
+    const packageJsonFile = path.join(tmpDir, 'package.json')
+    fs.writeFileSync(packageJsonFile, JSON.stringify({ type: 'module' }, null, 4))
+    const env = { TERM: ' dumb', TZ: 'UTC' }
+    const child = spawn(process.argv[0], [bin], { env, cwd: tmpDir })
+    // Validate that the time has been translated
+    child.on('error', t.assert.fail)
+    const endPromise = once(child.stdout, 'data', (data) => {
+      t.assert.strictEqual(data.toString(), '[17:35:28.992] INFO (42): hello world\n')
+    })
+    child.stdin.write(logLine)
+    await endPromise
+    t.after(() => {
+      fs.unlinkSync(configFile)
+      fs.unlinkSync(packageJsonFile)
+      child.kill()
+    })
+  })
+
+  test('loads and applies default config file: .pino-prettyrc', async (t) => {
+    t.plan(1)
+    // Set translateTime: true on run configuration
+    const configFile = path.join(tmpDir, '.pino-prettyrc')
+    fs.writeFileSync(configFile, JSON.stringify({ translateTime: true }, null, 4))
+    const env = { TERM: ' dumb', TZ: 'UTC' }
+    const child = spawn(process.argv[0], [bin], { env, cwd: tmpDir })
+    // Validate that the time has been translated
+    child.on('error', t.assert.fail)
+    const endPromise = once(child.stdout, 'data', (data) => {
+      t.assert.strictEqual(data.toString(), '[17:35:28.992] INFO (42): hello world\n')
+    })
+    child.stdin.write(logLine)
+    await endPromise
+    t.after(() => {
+      fs.unlinkSync(configFile)
+      child.kill()
+    })
+  })
+
+  test('loads and applies default config file: .pino-prettyrc.json', async (t) => {
+    t.plan(1)
+    // Set translateTime: true on run configuration
+    const configFile = path.join(tmpDir, '.pino-prettyrc.json')
+    fs.writeFileSync(configFile, JSON.stringify({ translateTime: true }, null, 4))
+    const env = { TERM: ' dumb', TZ: 'UTC' }
+    const child = spawn(process.argv[0], [bin], { env, cwd: tmpDir })
+    // Validate that the time has been translated
+    child.on('error', t.assert.fail)
+    const endPromise = once(child.stdout, 'data', (data) => {
+      t.assert.strictEqual(data.toString(), '[17:35:28.992] INFO (42): hello world\n')
+    })
+    child.stdin.write(logLine)
+    await endPromise
+    t.after(() => {
+      fs.unlinkSync(configFile)
+      child.kill()
+    })
+  })
+
+  test('loads and applies custom config file: pino-pretty.config.test.json', async (t) => {
+    t.plan(1)
+    // Set translateTime: true on run configuration
+    const configFile = path.join(tmpDir, 'pino-pretty.config.test.json')
+    fs.writeFileSync(configFile, JSON.stringify({ translateTime: true }, null, 4))
+    const env = { TERM: ' dumb', TZ: 'UTC' }
+    const child = spawn(process.argv[0], [bin, '--config', configFile], { env, cwd: tmpDir })
+    // Validate that the time has been translated
+    child.on('error', t.assert.fail)
+    const endPromise = once(child.stdout, 'data', (data) => {
+      t.assert.strictEqual(data.toString(), '[17:35:28.992] INFO (42): hello world\n')
+    })
+    child.stdin.write(logLine)
+    await endPromise
+    t.after(() => child.kill())
+  })
+
+  test('loads and applies custom config file: pino-pretty.config.test.js', async (t) => {
+    t.plan(1)
+    // Set translateTime: true on run configuration
+    const configFile = path.join(tmpDir, 'pino-pretty.config.test.js')
+    fs.writeFileSync(configFile, 'module.exports = { translateTime: true }')
+    const env = { TERM: ' dumb', TZ: 'UTC' }
+    const child = spawn(process.argv[0], [bin, '--config', configFile], { env, cwd: tmpDir })
+    // Validate that the time has been translated
+    child.on('error', t.assert.fail)
+    const endPromise = once(child.stdout, 'data', (data) => {
+      t.assert.strictEqual(data.toString(), '[17:35:28.992] INFO (42): hello world\n')
+    })
+    child.stdin.write(logLine)
+    await endPromise
+    t.after(() => child.kill())
+  })
+
+  for (const optionName of ['--messageKey', '-m']) {
+    test(`cli options override config options via ${optionName}`, async (t) => {
+      t.plan(1)
+      // Set translateTime: true on run configuration
+      const configFile = path.join(tmpDir, 'pino-pretty.config.js')
+      fs.writeFileSync(configFile, `
+        module.exports = {
+          translateTime: true,
+          messageKey: 'custom_msg'
+        }
+      `.trim())
+      // Set messageKey: 'new_msg' using command line option
+      const env = { TERM: ' dumb', TZ: 'UTC' }
+      const child = spawn(process.argv[0], [bin, optionName, 'new_msg'], { env, cwd: tmpDir })
+      // Validate that the time has been translated and correct message key has been used
+      child.on('error', t.assert.fail)
+      const endPromise = once(child.stdout, 'data', (data) => {
+        t.assert.strictEqual(data.toString(), '[17:35:28.992] INFO (42): hello world\n')
+      })
+      child.stdin.write(logLine.replace(/"msg"/, '"new_msg"'))
+      await endPromise
+      t.after(() => {
+        fs.unlinkSync(configFile)
+        child.kill()
+      })
+    })
+  }
+
+  test('cli options with defaults can be overridden by config', async (t) => {
+    t.plan(1)
+    // Set errorProps: '*' on run configuration
+    const configFile = path.join(tmpDir, 'pino-pretty.config.js')
+    fs.writeFileSync(configFile, `
+      module.exports = {
+          errorProps: '*'
+      }
+    `.trim())
+    // Set messageKey: 'new_msg' using command line option
+    const env = { TERM: ' dumb', TZ: 'UTC' }
+    const child = spawn(process.argv[0], [bin], { env, cwd: tmpDir })
+    // Validate that the time has been translated and correct message key has been used
+    child.on('error', t.assert.fail)
+    const endPromise = once(child.stdout, 'data', (data) => {
+      t.assert.strictEqual(data.toString(), '[21:31:36.006] FATAL: There was an error starting the process.\n    QueryError: Error during sql query: syntax error at or near SELECTT\n        at /home/me/projects/example/sql.js\n        at /home/me/projects/example/index.js\n    querySql: SELECTT * FROM "test" WHERE id = $1;\n    queryArgs: 12\n')
+    })
+    child.stdin.write('{"level":60,"time":1594416696006,"msg":"There was an error starting the process.","type":"Error","stack":"QueryError: Error during sql query: syntax error at or near SELECTT\\n    at /home/me/projects/example/sql.js\\n    at /home/me/projects/example/index.js","querySql":"SELECTT * FROM \\"test\\" WHERE id = $1;","queryArgs":[12]}\n')
+    await endPromise
+    t.after(() => {
+      fs.unlinkSync(configFile)
+      child.kill()
+    })
+  })
+
+  test('throws on missing config file', async (t) => {
+    t.plan(2)
+    const args = [bin, '--config', 'pino-pretty.config.missing.json']
+    const env = { TERM: ' dumb', TZ: 'UTC' }
+    const child = spawn(process.argv[0], args, { env, cwd: tmpDir })
+    const endPromise1 = once(child, 'close', (code) => {
+      t.assert.strictEqual(code, 1)
+    })
+    child.stdout.pipe(process.stdout)
+    child.stderr.setEncoding('utf8')
+    let data = ''
+    child.stderr.on('data', (chunk) => {
+      data += chunk
+    })
+    const endPromise2 = once(child, 'close', () => {
+      match(
+        data.toString(), 'Error: Failed to load runtime configuration file: pino-pretty.config.missing.json', t)
+    })
+    await Promise.all([endPromise1, endPromise2])
+    t.after(() => child.kill())
+  })
+
+  test('throws on invalid default config file', async (t) => {
+    t.plan(2)
+    const configFile = path.join(tmpDir, 'pino-pretty.config.js')
+    fs.writeFileSync(configFile, 'module.exports = () => {}')
+    const env = { TERM: ' dumb', TZ: 'UTC' }
+    const child = spawn(process.argv[0], [bin], { env, cwd: tmpDir })
+    const endPromise1 = once(child, 'close', (code) => {
+      t.assert.strictEqual(code, 1)
+    })
+    child.stdout.pipe(process.stdout)
+    child.stderr.setEncoding('utf8')
+    let data = ''
+    child.stderr.on('data', (chunk) => {
+      data += chunk
+    })
+    const endPromise2 = once(child, 'close', () => {
+      match(data, 'Error: Invalid runtime configuration file: pino-pretty.config.js', t)
+    })
+    await Promise.all([endPromise1, endPromise2])
+    t.after(() => child.kill())
+  })
+
+  test('throws on invalid custom config file', async (t) => {
+    t.plan(2)
+    const configFile = path.join(tmpDir, 'pino-pretty.config.invalid.js')
+    fs.writeFileSync(configFile, 'module.exports = () => {}')
+    const args = [bin, '--config', path.relative(tmpDir, configFile)]
+    const env = { TERM: ' dumb', TZ: 'UTC' }
+    const child = spawn(process.argv[0], args, { env, cwd: tmpDir })
+    const endPromise1 = once(child, 'close', (code) => {
+      t.assert.strictEqual(code, 1)
+    })
+    child.stdout.pipe(process.stdout)
+    child.stderr.setEncoding('utf8')
+    let data = ''
+    child.stderr.on('data', (chunk) => {
+      data += chunk
+    })
+    const endPromise2 = once(child, 'close', () => {
+      match(data, 'Error: Invalid runtime configuration file: pino-pretty.config.invalid.js', t)
+    })
+    await Promise.all([endPromise1, endPromise2])
+    t.after(() => child.kill())
+  })
+
+  test('test help', async (t) => {
+    t.plan(1)
+    const env = { TERM: ' dumb', TZ: 'UTC' }
+    const child = spawn(process.argv[0], [bin, '--help'], { env })
+    const file = fs.readFileSync('help/help.txt').toString()
+    child.on('error', t.assert.fail)
+
+    await new Promise(resolve => {
+      child.stdout.on('data', (data) => {
+        t.assert.strictEqual(data.toString(), file)
+        resolve()
+      })
+    })
+    t.after(() => child.kill())
+  })
+})