@zuplo/cli 7.0.2 → 7.1.0

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

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

package/node_modules/pino/test/transport/{syncfalse.test.js → sync-false.test.js}

@@ -1,17 +1,19 @@
 'use strict'
 
+const test = require('node:test')
+const assert = require('node:assert')
 const os = require('node:os')
-const pino = require('../..')
 const { join } = require('node:path')
-const { test } = require('tap')
 const { readFile } = require('node:fs').promises
-const { watchFileCreated, file } = require('../helper')
 const { promisify } = require('node:util')
 
+const pino = require('../..')
+const { watchFileCreated, watchForWrite, file } = require('../helper')
+
 const { pid } = process
 const hostname = os.hostname()
 
-test('thread-stream async flush', async ({ equal, same }) => {
+test('thread-stream async flush', async () => {
   const destination = file()
   const transport = pino.transport({
     target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
@@ -20,12 +22,12 @@ test('thread-stream async flush', async ({ equal, same }) => {
   const instance = pino(transport)
   instance.info('hello')
 
-  equal(instance.flush(), undefined)
+  assert.equal(instance.flush(), undefined)
 
   await watchFileCreated(destination)
   const result = JSON.parse(await readFile(destination))
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 30,
@@ -33,7 +35,7 @@ test('thread-stream async flush', async ({ equal, same }) => {
   })
 })
 
-test('thread-stream async flush should call the passed callback', async (t) => {
+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)
@@ -51,18 +53,15 @@ test('thread-stream async flush should call the passed callback', async (t) => {
 
   const [firstFlushData] = await getOutputLogLines()
 
-  t.equal(firstFlushData.msg, 'hello')
+  assert.equal(firstFlushData.msg, 'hello')
 
-  // should not flush this as no data accumulated that's bigger than min length
   instance.info('world')
 
-  // Making sure data is not flushed yet
-  const afterLogData = await getOutputLogLines()
-  t.equal(afterLogData.length, 1)
-
   await flushPromise()
+  await watchForWrite(outputPath, 'world')
 
-  // Making sure data is not flushed yet
-  const afterSecondFlush = (await getOutputLogLines())[1]
-  t.equal(afterSecondFlush.msg, 'world')
+  // After flush, both messages should be present
+  const afterSecondFlush = await getOutputLogLines()
+  assert.equal(afterSecondFlush.length, 2)
+  assert.equal(afterSecondFlush[1].msg, 'world')
 })

package/node_modules/pino/test/transport/{syncTrue.test.js → sync-true.test.js}

@@ -1,12 +1,14 @@
 'use strict'
 
-const pino = require('../..')
+const test = require('node:test')
+const assert = require('node:assert')
 const { join } = require('node:path')
 const { readFileSync } = require('node:fs')
-const { test } = require('tap')
+
 const { file } = require('../helper')
+const pino = require('../..')
 
-test('thread-stream sync true should log synchronously', async (t) => {
+test('thread-stream sync true should log synchronously', async () => {
   const outputPath = file()
 
   function getOutputLogLines () {
@@ -51,5 +53,5 @@ test('thread-stream sync true should log synchronously', async (t) => {
     throw new Error('Sync loop did not get interrupt')
   }
 
-  t.equal(flushData.length, 6)
+  assert.equal(flushData.length, 6)
 })

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

@@ -1,18 +1,19 @@
 'use strict'
 
-const { test } = require('tap')
+const test = require('node:test')
 const { join } = require('node:path')
-const proxyquire = require('proxyquire')
 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 ({ equal, same, plan, pass }) {
-  plan(1)
+test('file-target mocked', async function (t) {
+  const plan = tspl(t, { plan: 1 })
   let ret
   const fileTarget = proxyquire('../../file', {
     './pino': {
       destination (opts) {
-        same(opts, { dest: 1, sync: false })
+        plan.deepEqual(opts, { dest: 1, sync: false })
 
         ret = new Writable()
         ret.fd = opts.dest
@@ -27,18 +28,21 @@ test('file-target mocked', async function ({ equal, same, plan, pass }) {
   })
 
   await fileTarget()
+  await plan
 })
 
-test('pino.transport with syntax error', ({ same, teardown, plan }) => {
-  plan(1)
+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')
     }]
   })
-  teardown(transport.end.bind(transport))
+  t.after(transport.end.bind(transport))
 
   transport.on('error', (err) => {
-    same(err, new SyntaxError('Unexpected end of input'))
+    plan.deepEqual(err, new SyntaxError('Unexpected end of input'))
   })
+
+  await plan
 })

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

@@ -1,11 +1,13 @@
 '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 { watchFileCreated, file } = require('../helper')
-const { test } = require('tap')
 const pino = require('../../')
 
 const { pid } = process
@@ -23,8 +25,7 @@ function parseLogs (buffer) {
   return JSON.parse(`[${buffer.toString().replace(/}{/g, '},{')}]`)
 }
 
-test('transport uses pino config', async ({ same, teardown, plan }) => {
-  plan(1)
+test('transport uses pino config', async (t) => {
   const destination = file()
   const transport = pino.transport({
     pipeline: [{
@@ -34,7 +35,7 @@ test('transport uses pino config', async ({ same, teardown, plan }) => {
       options: { destination }
     }]
   })
-  teardown(transport.end.bind(transport))
+  t.after(transport.end.bind(transport))
   const instance = pino({
     messageKey: 'customMessageKey',
     errorKey: 'customErrorKey',
@@ -47,7 +48,7 @@ test('transport uses pino config', async ({ same, teardown, plan }) => {
   await watchFileCreated(destination)
   const result = parseLogs(await readFile(destination))
 
-  same(result, [{
+  assert.deepEqual(result, [{
     severityText: 'custom',
     body: 'foo',
     attributes: {
@@ -65,8 +66,7 @@ test('transport uses pino config', async ({ same, teardown, plan }) => {
   }])
 })
 
-test('transport uses pino config without customizations', async ({ same, teardown, plan }) => {
-  plan(1)
+test('transport uses pino config without customizations', async (t) => {
   const destination = file()
   const transport = pino.transport({
     pipeline: [{
@@ -76,7 +76,7 @@ test('transport uses pino config without customizations', async ({ same, teardow
       options: { destination }
     }]
   })
-  teardown(transport.end.bind(transport))
+  t.after(transport.end.bind(transport))
   const instance = pino(transport)
 
   const error = new Error('qux')
@@ -85,7 +85,7 @@ test('transport uses pino config without customizations', async ({ same, teardow
   await watchFileCreated(destination)
   const result = parseLogs(await readFile(destination))
 
-  same(result, [{
+  assert.deepEqual(result, [{
     severityText: 'info',
     body: 'baz',
     attributes: {
@@ -103,8 +103,7 @@ test('transport uses pino config without customizations', async ({ same, teardow
   }])
 })
 
-test('transport uses pino config with multistream', async ({ same, teardown, plan }) => {
-  plan(2)
+test('transport uses pino config with multistream', async (t) => {
   const destination = file()
   const messages = []
   const stream = writeStream(function (data, enc, cb) {
@@ -121,7 +120,7 @@ test('transport uses pino config with multistream', async ({ same, teardown, pla
       options: { destination }
     }]
   })
-  teardown(transport.end.bind(transport))
+  t.after(transport.end.bind(transport))
   const instance = pino({
     messageKey: 'customMessageKey',
     errorKey: 'customErrorKey',
@@ -135,7 +134,7 @@ test('transport uses pino config with multistream', async ({ same, teardown, pla
   await watchFileCreated(destination)
   const result = parseLogs(await readFile(destination))
 
-  same(result, [{
+  assert.deepEqual(result, [{
     severityText: 'custom',
     body: 'fizz',
     attributes: {
@@ -152,7 +151,7 @@ test('transport uses pino config with multistream', async ({ same, teardown, pla
     error: serializedError
   }])
 
-  same(messages, [{
+  assert.deepEqual(messages, [{
     level: 35,
     pid,
     hostname,

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

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

package/node_modules/pino/test/types/{pino-import.test-d.ts → pino-import.test-d.cts}

@@ -1,8 +1,7 @@
 import { expectType } from "tsd";
 
-import pino from '../../pino';
-import { pino as pinoNamed, P } from "../../pino";
 import * as pinoStar from "../../pino";
+import { default as P, default as pino, pino as pinoNamed } from '../../pino';
 import pinoCjsImport = require ("../../pino");
 const pinoCjs = require("../../pino");
 const { P: pinoCjsNamed } = require('pino')
@@ -15,10 +14,12 @@ expectType<pino.Logger>(pinoNamed());
 expectType<P.Logger>(pinoNamed());
 expectType<pino.Logger>(pinoStar.default());
 expectType<pino.Logger>(pinoStar.pino());
-expectType<pino.Logger>(pinoCjsImport.default());
+// expectType<pino.Logger>(pinoCjsImport.default());
 expectType<pino.Logger>(pinoCjsImport.pino());
 expectType<any>(pinoCjsNamed());
 expectType<any>(pinoCjs());
+expectType<P.TimeFn>(pinoNamed.stdTimeFunctions.isoTimeNano)
+expectType<string>(pinoNamed.stdTimeFunctions.isoTimeNano())
 
 const levelChangeEventListener: P.LevelChangeEventListener = (
     lvl: P.LevelWithSilent | string,

package/node_modules/pino/test/types/pino-multistream.test-d.ts

@@ -1,4 +1,4 @@
-import { expectType } from 'tsd'
+import { expectType, expectNotType } from 'tsd'
 
 import { createWriteStream } from 'node:fs'
 
@@ -18,11 +18,11 @@ expectType<pino.MultiStreamRes<'fatal'>>(pino.multistream([{ level: 'fatal' as c
 
 expectType<pino.MultiStreamRes<'error' | 'fatal'>>(pino.multistream(streams))
 expectType<pino.MultiStreamRes<'error' | 'fatal'>>(pino.multistream(streams, {}))
-expectType<pino.MultiStreamRes<'error' | 'fatal'>>(pino.multistream(streams, { levels: { 'info': 30 } }))
+expectType<pino.MultiStreamRes<'error' | 'fatal'>>(pino.multistream(streams, { levels: { info: 30 } }))
 expectType<pino.MultiStreamRes<'error' | 'fatal'>>(pino.multistream(streams, { dedupe: true }))
 expectType<pino.MultiStreamRes<'error' | 'fatal'>>(pino.multistream(streams[0]).add(streams[1]))
 expectType<pino.MultiStreamRes<'error' | 'fatal'>>(multistream(streams))
 expectType<pino.MultiStreamRes<'error'>>(multistream(streams).clone('error'))
+expectNotType<pino.MultiStreamRes<string>>(multistream(streams).clone('error'))
 
-
-expectType<pino.MultiStreamRes>(multistream(process.stdout));
+expectType<pino.MultiStreamRes>(multistream(process.stdout))

package/node_modules/pino/test/types/pino-top-export.test-d.ts

@@ -1,35 +1,34 @@
 import { expectType, expectAssignable } from 'tsd'
-import type { SonicBoom } from "sonic-boom";
+import type { SonicBoom } from 'sonic-boom'
 
-import {
-    destination,
-    LevelMapping,
-    levels,
-    Logger,
-    multistream,
-    MultiStreamRes,
-    SerializedError,
-    stdSerializers,
-    stdTimeFunctions,
-    symbols,
-    transport,
-    version,
-} from "../../pino";
-import pino from "../../pino";
+import pino, {
+  destination,
+  type LevelMapping,
+  levels,
+  type Logger,
+  multistream,
+  type MultiStreamRes,
+  type SerializedError,
+  stdSerializers,
+  stdTimeFunctions,
+  symbols,
+  transport,
+  version,
+} from '../../pino'
 
-expectType<SonicBoom>(destination(""));
-expectType<LevelMapping>(levels);
-expectType<MultiStreamRes>(multistream(process.stdout));
-expectType<SerializedError>(stdSerializers.err({} as any));
-expectType<string>(stdTimeFunctions.isoTime());
-expectType<string>(version);
+expectType<SonicBoom>(destination(''))
+expectType<LevelMapping>(levels)
+expectType<MultiStreamRes>(multistream(process.stdout))
+expectType<SerializedError>(stdSerializers.err({} as any))
+expectType<string>(stdTimeFunctions.isoTime())
+expectType<string>(stdTimeFunctions.isoTimeNano())
+expectType<string>(version)
 
 // Can't test against `unique symbol`, see https://github.com/SamVerschueren/tsd/issues/49
-expectAssignable<Symbol>(symbols.endSym);
+expectAssignable<Symbol>(symbols.endSym)
 
 // TODO: currently returns (aliased) `any`, waiting for strong typed `thread-stream`
 transport({
-    target: '#pino/pretty',
-    options: { some: 'options for', the: 'transport' }
-});
-
+  target: '#pino/pretty',
+  options: { some: 'options for', the: 'transport' }
+})

package/node_modules/pino/test/types/pino-transport.test-d.ts

@@ -1,145 +1,156 @@
-import { pino } from '../../pino'
-import { expectType } from "tsd";
+import pino from '../../pino'
+import { expectType } from 'tsd'
 
 // Single
 const transport = pino.transport({
-    target: '#pino/pretty',
-    options: { some: 'options for', the: 'transport' }
+  target: '#pino/pretty',
+  options: { some: 'options for', the: 'transport' }
 })
 pino(transport)
 
 expectType<pino.Logger>(pino({
-    transport: {
-        target: 'pino-pretty'
-    },
+  transport: {
+    target: 'pino-pretty'
+  },
 }))
 
 // Multiple
-const transports = pino.transport({targets: [
+const transports = pino.transport({
+  targets: [
     {
-        level: 'info',
-        target: '#pino/pretty',
-        options: { some: 'options for', the: 'transport' }
+      level: 'info',
+      target: '#pino/pretty',
+      options: { some: 'options for', the: 'transport' }
     },
     {
-        level: 'trace',
-        target: '#pino/file',
-        options: { destination: './test.log' }
+      level: 'trace',
+      target: '#pino/file',
+      options: { destination: './test.log' }
     }
-]})
+  ]
+})
 pino(transports)
 
 expectType<pino.Logger>(pino({
-    transport: {targets: [
-            {
-                level: 'info',
-                target: '#pino/pretty',
-                options: { some: 'options for', the: 'transport' }
-            },
-            {
-                level: 'trace',
-                target: '#pino/file',
-                options: { destination: './test.log' }
-            }
-        ]},
-}))
-
-const transportsWithCustomLevels = pino.transport({targets: [
-    {
+  transport: {
+    targets: [
+      {
         level: 'info',
         target: '#pino/pretty',
         options: { some: 'options for', the: 'transport' }
-    },
-    {
-        level: 'foo',
+      },
+      {
+        level: 'trace',
         target: '#pino/file',
         options: { destination: './test.log' }
+      }
+    ]
+  },
+}))
+
+const transportsWithCustomLevels = pino.transport({
+  targets: [
+    {
+      level: 'info',
+      target: '#pino/pretty',
+      options: { some: 'options for', the: 'transport' }
+    },
+    {
+      level: 'foo',
+      target: '#pino/file',
+      options: { destination: './test.log' }
     }
-], levels: { foo: 35 }})
+  ],
+  levels: { foo: 35 }
+})
 pino(transports)
 
 expectType<pino.Logger>(pino({
-    transport: {targets: [
-            {
-                level: 'info',
-                target: '#pino/pretty',
-                options: { some: 'options for', the: 'transport' }
-            },
-            {
-                level: 'trace',
-                target: '#pino/file',
-                options: { destination: './test.log' }
-            }
-        ], levels: { foo: 35 }
-    },
+  transport: {
+    targets: [
+      {
+        level: 'info',
+        target: '#pino/pretty',
+        options: { some: 'options for', the: 'transport' }
+      },
+      {
+        level: 'trace',
+        target: '#pino/file',
+        options: { destination: './test.log' }
+      }
+    ],
+    levels: { foo: 35 }
+  },
 }))
 
 const transportsWithoutOptions = pino.transport({
-    targets: [
-        { target: '#pino/pretty' },
-        { target: '#pino/file' }
-    ], levels: { foo: 35 }
+  targets: [
+    { target: '#pino/pretty' },
+    { target: '#pino/file' }
+  ],
+  levels: { foo: 35 }
 })
 pino(transports)
 
 expectType<pino.Logger>(pino({
-    transport: {
-        targets: [
-            { target: '#pino/pretty' },
-            { target: '#pino/file' }
-        ], levels: { foo: 35 }
-    },
+  transport: {
+    targets: [
+      { target: '#pino/pretty' },
+      { target: '#pino/file' }
+    ],
+    levels: { foo: 35 }
+  },
 }))
 
 const pipelineTransport = pino.transport({
-    pipeline: [{
-        target: './my-transform.js'
-    }, {
-        // Use target: 'pino/file' to write to stdout
-        // without any change.
-        target: 'pino-pretty'
-    }]
+  pipeline: [{
+    target: './my-transform.js'
+  }, {
+    // Use target: 'pino/file' to write to stdout
+    // without any change.
+    target: 'pino-pretty'
+  }]
 })
 pino(pipelineTransport)
 
 expectType<pino.Logger>(pino({
-    transport: {
-        pipeline: [{
-            target: './my-transform.js'
-        }, {
-            // Use target: 'pino/file' to write to stdout
-            // without any change.
-            target: 'pino-pretty'
-        }]
-    }
+  transport: {
+    pipeline: [{
+      target: './my-transform.js'
+    }, {
+      // Use target: 'pino/file' to write to stdout
+      // without any change.
+      target: 'pino-pretty'
+    }]
+  }
 }))
 
 type TransportConfig = {
-    id: string
+  id: string
 }
 
 // Custom transport params
 const customTransport = pino.transport<TransportConfig>({
-    target: 'custom',
-    options: { id: 'abc' }
+  target: 'custom',
+  options: { id: 'abc' }
 })
 pino(customTransport)
 
 // Worker
 pino.transport({
-    target: 'custom',
-    worker: {
-        argv: ['a', 'b'],
-        stdin: false,
-        stderr: true,
-        stdout: false,
-        autoEnd: true,
-    },
-    options: { id: 'abc' }
+  target: 'custom',
+  worker: {
+    argv: ['a', 'b'],
+    stdin: false,
+    stderr: true,
+    stdout: false,
+    autoEnd: true,
+  },
+  options: { id: 'abc' }
 })
 
 // Dedupe
 pino.transport({
-    targets: [],
-    dedupe: true,
+  targets: [],
+  dedupe: true,
 })