@farthershore/cli 0.3.8 → 0.3.10

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,67 @@
+'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 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)
+
+  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')
+})

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 { watchFileCreated, 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 watchFileCreated(destination)
+  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 watchFileCreated(destination)
+  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 watchFileCreated(destination)
+  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.test-d.cts

@@ -0,0 +1,30 @@
+import { expectType } from "tsd";
+
+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')
+
+const log = pino();
+expectType<P.LogFn>(log.info);
+expectType<P.LogFn>(log.error);
+
+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.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,
+    val: number,
+    prevLvl: P.LevelWithSilent | string,
+    prevVal: number,
+) => {}
+expectType<P.LevelChangeEventListener>(levelChangeEventListener)

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

@@ -0,0 +1,28 @@
+import { expectType, expectNotType } from 'tsd'
+
+import { createWriteStream } from 'node:fs'
+
+import pino, { multistream } from '../../pino'
+
+const streams = [
+  { stream: process.stdout },
+  { stream: createWriteStream('') },
+  { level: 'error' as const, stream: process.stderr },
+  { level: 'fatal' as const, stream: process.stderr },
+]
+
+expectType<pino.MultiStreamRes>(pino.multistream(process.stdout))
+expectType<pino.MultiStreamRes>(pino.multistream([createWriteStream('')]))
+expectType<pino.MultiStreamRes<'error'>>(pino.multistream({ level: 'error' as const, stream: process.stderr }))
+expectType<pino.MultiStreamRes<'fatal'>>(pino.multistream([{ level: 'fatal' as const, stream: createWriteStream('') }]))
+
+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, { 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))

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

@@ -0,0 +1,34 @@
+import { expectType, expectAssignable } from 'tsd'
+import type { SonicBoom } from 'sonic-boom'
+
+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>(stdTimeFunctions.isoTimeNano())
+expectType<string>(version)
+
+// Can't test against `unique symbol`, see https://github.com/SamVerschueren/tsd/issues/49
+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' }
+})