@farthershore/cli 0.3.10 → 0.3.11

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

@@ -1,137 +0,0 @@
-'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

@@ -1,54 +0,0 @@
-'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

@@ -1,15 +0,0 @@
-'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

@@ -1,67 +0,0 @@
-'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

@@ -1,57 +0,0 @@
-'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

@@ -1,48 +0,0 @@
-'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

@@ -1,166 +0,0 @@
-'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

@@ -1,40 +0,0 @@
-'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

@@ -1,30 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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' }
-})