@zuplo/cli 7.0.2 → 7.1.1

package/node_modules/pino/test/exit.test.js

@@ -1,13 +1,15 @@
 'use strict'
 
-const { test } = require('tap')
+const test = require('node:test')
+const assert = require('node:assert')
 const { join } = require('node:path')
+
 const execa = require('execa')
 const writer = require('flush-write-stream')
 const { once } = require('./helper')
 
 // https://github.com/pinojs/pino/issues/542
-test('pino.destination log everything when calling process.exit(0)', async ({ not }) => {
+test('pino.destination log everything when calling process.exit(0)', async () => {
   let actual = ''
   const child = execa(process.argv[0], [join(__dirname, 'fixtures', 'destination-exit.js')])
 
@@ -18,11 +20,11 @@ test('pino.destination log everything when calling process.exit(0)', async ({ no
 
   await once(child, 'close')
 
-  not(actual.match(/hello/), null)
-  not(actual.match(/world/), null)
+  assert.equal(actual.match(/hello/) != null, true)
+  assert.equal(actual.match(/world/) != null, true)
 })
 
-test('pino with no args log everything when calling process.exit(0)', async ({ not }) => {
+test('pino with no args log everything when calling process.exit(0)', async () => {
   let actual = ''
   const child = execa(process.argv[0], [join(__dirname, 'fixtures', 'default-exit.js')])
 
@@ -33,11 +35,11 @@ test('pino with no args log everything when calling process.exit(0)', async ({ n
 
   await once(child, 'close')
 
-  not(actual.match(/hello/), null)
-  not(actual.match(/world/), null)
+  assert.equal(actual.match(/hello/) != null, true)
+  assert.equal(actual.match(/world/) != null, true)
 })
 
-test('sync false logs everything when calling process.exit(0)', async ({ not }) => {
+test('sync false logs everything when calling process.exit(0)', async () => {
   let actual = ''
   const child = execa(process.argv[0], [join(__dirname, 'fixtures', 'syncfalse-exit.js')])
 
@@ -48,11 +50,11 @@ test('sync false logs everything when calling process.exit(0)', async ({ not })
 
   await once(child, 'close')
 
-  not(actual.match(/hello/), null)
-  not(actual.match(/world/), null)
+  assert.equal(actual.match(/hello/) != null, true)
+  assert.equal(actual.match(/world/) != null, true)
 })
 
-test('sync false logs everything when calling flushSync', async ({ not }) => {
+test('sync false logs everything when calling flushSync', async () => {
   let actual = ''
   const child = execa(process.argv[0], [join(__dirname, 'fixtures', 'syncfalse-flush-exit.js')])
 
@@ -63,15 +65,15 @@ test('sync false logs everything when calling flushSync', async ({ not }) => {
 
   await once(child, 'close')
 
-  not(actual.match(/hello/), null)
-  not(actual.match(/world/), null)
+  assert.equal(actual.match(/hello/) != null, true)
+  assert.equal(actual.match(/world/) != null, true)
 })
 
-test('transports exits gracefully when logging in exit', async ({ equal }) => {
+test('transports exits gracefully when logging in exit', async () => {
   const child = execa(process.argv[0], [join(__dirname, 'fixtures', 'transport-with-on-exit.js')])
   child.stdout.resume()
 
   const code = await once(child, 'close')
 
-  equal(code, 0)
+  assert.equal(code, 0)
 })

package/node_modules/pino/test/fixtures/crashing-transport.js

@@ -0,0 +1,13 @@
+const { Writable } = require('node:stream')
+
+module.exports = () =>
+  new Writable({
+    autoDestroy: true,
+    write (chunk, enc, cb) {
+      setImmediate(() => {
+        /* eslint-disable no-empty */
+        for (let i = 0; i < 1e3; i++) {}
+        process.exit(0)
+      })
+    }
+  })

package/node_modules/pino/test/fixtures/transport-invalid-node-options.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const pino = require('../../')
+const { join } = require('node:path')
+
+const destination = process.argv[2]
+
+process.env.NODE_OPTIONS = `--require ${join(__dirname, 'this-file-does-not-exist.js')}`
+
+const transport = pino.transport({
+  target: join(__dirname, 'to-file-transport.js'),
+  options: { destination }
+})
+
+const logger = pino(transport)
+transport.on('ready', () => {
+  logger.info('hello with invalid node options preload')
+  setTimeout(() => {
+    transport.end()
+  }, 50)
+})
+
+transport.on('error', (err) => {
+  process.stderr.write(`${err.stack}\n`)
+  process.exitCode = 1
+})

package/node_modules/pino/test/fixtures/transport-preload-main.mjs

@@ -0,0 +1,13 @@
+'use strict'
+
+// This is the main script that runs after the preload
+// It imports the logger from the preload and logs a message
+
+import { log } from './transport-preload.mjs'
+
+log.info('hello from main')
+
+// Wait a bit for the transport to flush
+setTimeout(() => {
+  process.exit(0)
+}, 500)

package/node_modules/pino/test/fixtures/transport-preload.mjs

@@ -0,0 +1,13 @@
+'use strict'
+
+import pino from '../../pino.js'
+import { join } from 'node:path'
+
+const log = pino({
+  transport: {
+    target: join(import.meta.dirname, 'to-file-transport.js'),
+    options: { destination: process.argv[2] }
+  }
+})
+
+export { log }

package/node_modules/pino/test/fixtures/transport-worker-name.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const { parentPort, threadName } = require('worker_threads')
+const { Writable } = require('node:stream')
+
+let sent = false
+
+module.exports = (options) => {
+  const myTransportStream = new Writable({
+    autoDestroy: true,
+    write (chunk, enc, cb) {
+      if (!sent) {
+        sent = true
+        parentPort.postMessage({
+          code: 'EVENT',
+          name: 'workerThreadName',
+          args: [threadName]
+        })
+      }
+      cb()
+    }
+  })
+  return myTransportStream
+}

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

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

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

@@ -2,7 +2,7 @@ import * as fs from 'node:fs'
 import { once } from 'node:events'
 import { Transform } from 'node:stream'
 
-async function run (opts: {  destination?: fs.PathLike }): Promise<Transform> {
+async function run (opts: { destination?: fs.PathLike }): Promise<Transform> {
   if (!opts.destination) throw new Error('kaboom')
   const stream = fs.createWriteStream(opts.destination)
   await once(stream, 'open')

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

@@ -1,14 +1,17 @@
 '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 { test } = require('tap')
-const { sink, once, watchFileCreated, file } = require('./helper')
+const tspl = require('@matteo.collina/tspl')
+
+const { sink, match, once, watchFileCreated, file } = require('./helper')
 const pino = require('../')
 
-test('level formatter', async ({ match }) => {
+test('level formatter', async () => {
   const stream = sink()
   const logger = pino({
     formatters: {
@@ -31,7 +34,7 @@ test('level formatter', async ({ match }) => {
   })
 })
 
-test('bindings formatter', async ({ match }) => {
+test('bindings formatter', async () => {
   const stream = sink()
   const logger = pino({
     formatters: {
@@ -60,7 +63,7 @@ test('bindings formatter', async ({ match }) => {
   })
 })
 
-test('no bindings formatter', async ({ match, notOk }) => {
+test('no bindings formatter', async () => {
   const stream = sink()
   const logger = pino({
     formatters: {
@@ -73,17 +76,18 @@ test('no bindings formatter', async ({ match, notOk }) => {
   const o = once(stream, 'data')
   logger.info('hello world')
   const log = await o
-  notOk(log.hasOwnProperty('pid'))
-  notOk(log.hasOwnProperty('hostname'))
+  assert.equal(log.hasOwnProperty('pid'), false)
+  assert.equal(log.hasOwnProperty('hostname'), false)
   match(log, { msg: 'hello world' })
 })
 
-test('log formatter', async ({ match, equal }) => {
+test('log formatter', async (t) => {
+  const plan = tspl(t, { plan: 1 })
   const stream = sink()
   const logger = pino({
     formatters: {
       log (obj) {
-        equal(obj.hasOwnProperty('msg'), false)
+        plan.equal(obj.hasOwnProperty('msg'), false)
         return { hello: 'world', ...obj }
       }
     }
@@ -96,9 +100,11 @@ test('log formatter', async ({ match, equal }) => {
     foo: 'bar',
     nested: { object: true }
   })
+
+  await plan
 })
 
-test('Formatters combined', async ({ match }) => {
+test('Formatters combined', async () => {
   const stream = sink()
   const logger = pino({
     formatters: {
@@ -143,7 +149,7 @@ test('Formatters combined', async ({ match }) => {
   })
 })
 
-test('Formatters in child logger', async ({ match }) => {
+test('Formatters in child logger', async () => {
   const stream = sink()
   const logger = pino({
     formatters: {
@@ -200,7 +206,7 @@ test('Formatters in child logger', async ({ match }) => {
   })
 })
 
-test('Formatters without bindings in child logger', async ({ match }) => {
+test('Formatters without bindings in child logger', async () => {
   const stream = sink()
   const logger = pino({
     formatters: {
@@ -256,7 +262,7 @@ test('Formatters without bindings in child logger', async ({ match }) => {
   })
 })
 
-test('elastic common schema format', async ({ match, type }) => {
+test('elastic common schema format', async () => {
   const stream = sink()
   const ecs = {
     formatters: {
@@ -291,7 +297,7 @@ test('elastic common schema format', async ({ match, type }) => {
   const o = once(stream, 'data')
   logger.info({ foo: 'bar' }, 'hello world')
   const log = await o
-  type(log['@timestamp'], 'string')
+  assert.equal(typeof log['@timestamp'], 'string')
   match(log, {
     log: { level: 'info', logger: 'pino' },
     process: { pid: process.pid },
@@ -302,12 +308,13 @@ test('elastic common schema format', async ({ match, type }) => {
   })
 })
 
-test('formatter with transport', async ({ match, equal }) => {
+test('formatter with transport', async (t) => {
+  const plan = tspl(t, { plan: 1 })
   const destination = file()
   const logger = pino({
     formatters: {
       log (obj) {
-        equal(obj.hasOwnProperty('msg'), false)
+        plan.equal(obj.hasOwnProperty('msg'), false)
         return { hello: 'world', ...obj }
       }
     },
@@ -332,24 +339,26 @@ test('formatter with transport', async ({ match, equal }) => {
   })
 })
 
-test('throws when custom level formatter is used with transport.targets', async ({ throws }) => {
-  throws(() => {
-    pino({
-      formatters: {
-        level (label) {
-          return label
-        }
-      },
-      transport: {
-        targets: [
-          {
-            target: 'pino/file',
-            options: { destination: 'foo.log' }
+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'))
+      )
+    },
+    Error('option.transport.targets do not allow custom level formatters')
+  )
 })

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

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

@@ -1,14 +1,14 @@
 'use strict'
 
-const crypto = require('crypto')
+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 { existsSync, readFileSync, statSync, unlinkSync } = require('node:fs')
+
 const pid = process.pid
 const hostname = os.hostname()
-const t = require('tap')
-const { join } = require('node:path')
 const { tmpdir } = os
 
 const isWin = process.platform === 'win32'
@@ -112,17 +112,44 @@ function file () {
 
 process.on('beforeExit', () => {
   if (files.length === 0) return
-  t.comment('unlink files')
   for (const file of files) {
     try {
-      t.comment(`unliking ${file}`)
       unlinkSync(file)
     } catch (e) {
-      console.log(e)
     }
   }
   files = []
-  t.comment('unlink completed')
 })
 
-module.exports = { getPathToNull, sink, check, once, sleep, watchFileCreated, watchForWrite, isWin, isYarnPnp, file }
+/**
+ * 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
+}

package/node_modules/pino/test/hooks.test.js

@@ -1,25 +1,27 @@
 'use strict'
 
-const tap = require('tap')
-const { sink, once } = require('./helper')
+const { describe, test } = require('node:test')
+const tspl = require('@matteo.collina/tspl')
+
+const { sink, match, once } = require('./helper')
 const pino = require('../')
 
-tap.test('log method hook', t => {
-  t.test('gets invoked', async t => {
-    t.plan(8)
+describe('log method hook', () => {
+  test('gets invoked', async t => {
+    const plan = tspl(t, { plan: 7 })
 
     const stream = sink()
     const logger = pino({
       hooks: {
         logMethod (args, method, level) {
-          t.type(args, Array)
-          t.type(level, 'number')
-          t.equal(args.length, 3)
-          t.equal(level, this.levels.values.info)
-          t.same(args, ['a', 'b', 'c'])
+          plan.equal(Array.isArray(args), true)
+          plan.equal(typeof level, 'number')
+          plan.equal(args.length, 3)
+          plan.equal(level, this.levels.values.info)
+          plan.deepEqual(args, ['a', 'b', 'c'])
 
-          t.type(method, Function)
-          t.equal(method.name, 'LOG')
+          plan.equal(typeof method, 'function')
+          plan.equal(method.name, 'LOG')
 
           method.apply(this, [args.join('-')])
         }
@@ -28,17 +30,17 @@ tap.test('log method hook', t => {
 
     const o = once(stream, 'data')
     logger.info('a', 'b', 'c')
-    t.match(await o, { msg: 'a-b-c' })
+    match(await o, { msg: 'a-b-c' })
   })
 
-  t.test('fatal method invokes hook', async t => {
-    t.plan(2)
+  test('fatal method invokes hook', async t => {
+    const plan = tspl(t, { plan: 1 })
 
     const stream = sink()
     const logger = pino({
       hooks: {
         logMethod (args, method) {
-          t.pass()
+          plan.ok(true)
           method.apply(this, [args.join('-')])
         }
       }
@@ -46,17 +48,17 @@ tap.test('log method hook', t => {
 
     const o = once(stream, 'data')
     logger.fatal('a')
-    t.match(await o, { msg: 'a' })
+    match(await o, { msg: 'a' })
   })
 
-  t.test('children get the hook', async t => {
-    t.plan(4)
+  test('children get the hook', async t => {
+    const plan = tspl(t, { plan: 2 })
 
     const stream = sink()
     const root = pino({
       hooks: {
         logMethod (args, method) {
-          t.pass()
+          plan.ok(true)
           method.apply(this, [args.join('-')])
         }
       }
@@ -66,22 +68,22 @@ tap.test('log method hook', t => {
 
     let o = once(stream, 'data')
     child.info('a', 'b')
-    t.match(await o, { msg: 'a-b' })
+    match(await o, { msg: 'a-b' })
 
     o = once(stream, 'data')
     grandchild.info('c', 'd')
-    t.match(await o, { msg: 'c-d' })
+    match(await o, { msg: 'c-d' })
   })
 
-  t.test('get log level', async t => {
-    t.plan(3)
+  test('get log level', async t => {
+    const plan = tspl(t, { plan: 2 })
 
     const stream = sink()
     const logger = pino({
       hooks: {
         logMethod (args, method, level) {
-          t.type(level, 'number')
-          t.equal(level, this.levels.values.error)
+          plan.equal(typeof level, 'number')
+          plan.equal(level, this.levels.values.error)
 
           method.apply(this, [args.join('-')])
         }
@@ -90,8 +92,23 @@ tap.test('log method hook', t => {
 
     const o = once(stream, 'data')
     logger.error('a')
-    t.match(await o, { msg: 'a' })
+    match(await o, { msg: 'a' })
   })
+})
 
-  t.end()
+describe('streamWrite hook', () => {
+  test('gets invoked', async () => {
+    const stream = sink()
+    const logger = pino({
+      hooks: {
+        streamWrite (s) {
+          return s.replaceAll('redact-me', 'XXX')
+        }
+      }
+    }, stream)
+
+    const o = once(stream, 'data')
+    logger.info('hide redact-me in this string')
+    match(await o, { msg: 'hide XXX in this string' })
+  })
 })