@farthershore/cli 0.3.10 → 0.3.11

package/node_modules/pino/test/serializers.test.js

@@ -1,257 +0,0 @@
-'use strict'
-
-const test = require('node:test')
-const assert = require('node:assert')
-const stdSerializers = require('pino-std-serializers')
-
-const { sink, once } = require('./helper')
-const pino = require('../')
-
-const parentSerializers = {
-  test: () => 'parent'
-}
-
-const childSerializers = {
-  test: () => 'child'
-}
-
-test('default err namespace error serializer', async () => {
-  const stream = sink()
-  const parent = pino(stream)
-
-  parent.info({ err: ReferenceError('test') })
-  const o = await once(stream, 'data')
-  assert.equal(typeof o.err, 'object')
-  assert.equal(o.err.type, 'ReferenceError')
-  assert.equal(o.err.message, 'test')
-  assert.equal(typeof o.err.stack, 'string')
-})
-
-test('custom serializer overrides default err namespace error serializer', async () => {
-  const stream = sink()
-  const parent = pino({
-    serializers: {
-      err: (e) => ({
-        t: e.constructor.name,
-        m: e.message,
-        s: e.stack
-      })
-    }
-  }, stream)
-
-  parent.info({ err: ReferenceError('test') })
-  const o = await once(stream, 'data')
-  assert.equal(typeof o.err, 'object')
-  assert.equal(o.err.t, 'ReferenceError')
-  assert.equal(o.err.m, 'test')
-  assert.equal(typeof o.err.s, 'string')
-})
-
-test('custom serializer overrides default err namespace error serializer when nestedKey is on', async () => {
-  const stream = sink()
-  const parent = pino({
-    nestedKey: 'obj',
-    serializers: {
-      err: (e) => {
-        return {
-          t: e.constructor.name,
-          m: e.message,
-          s: e.stack
-        }
-      }
-    }
-  }, stream)
-
-  parent.info({ err: ReferenceError('test') })
-  const o = await once(stream, 'data')
-  assert.equal(typeof o.obj.err, 'object')
-  assert.equal(o.obj.err.t, 'ReferenceError')
-  assert.equal(o.obj.err.m, 'test')
-  assert.equal(typeof o.obj.err.s, 'string')
-})
-
-test('null overrides default err namespace error serializer', async () => {
-  const stream = sink()
-  const parent = pino({ serializers: { err: null } }, stream)
-
-  parent.info({ err: ReferenceError('test') })
-  const o = await once(stream, 'data')
-  assert.equal(typeof o.err, 'object')
-  assert.equal(typeof o.err.type, 'undefined')
-  assert.equal(typeof o.err.message, 'undefined')
-  assert.equal(typeof o.err.stack, 'undefined')
-})
-
-test('undefined overrides default err namespace error serializer', async () => {
-  const stream = sink()
-  const parent = pino({ serializers: { err: undefined } }, stream)
-
-  parent.info({ err: ReferenceError('test') })
-  const o = await once(stream, 'data')
-  assert.equal(typeof o.err, 'object')
-  assert.equal(typeof o.err.type, 'undefined')
-  assert.equal(typeof o.err.message, 'undefined')
-  assert.equal(typeof o.err.stack, 'undefined')
-})
-
-test('serializers override values', async () => {
-  const stream = sink()
-  const parent = pino({ serializers: parentSerializers }, stream)
-  parent.child({}, { serializers: childSerializers })
-
-  parent.fatal({ test: 'test' })
-  const o = await once(stream, 'data')
-  assert.equal(o.test, 'parent')
-})
-
-test('child does not overwrite parent serializers', async () => {
-  const stream = sink()
-  const parent = pino({ serializers: parentSerializers }, stream)
-  const child = parent.child({}, { serializers: childSerializers })
-
-  parent.fatal({ test: 'test' })
-
-  const o = once(stream, 'data')
-  assert.equal((await o).test, 'parent')
-  const o2 = once(stream, 'data')
-  child.fatal({ test: 'test' })
-  assert.equal((await o2).test, 'child')
-})
-
-test('Symbol.for(\'pino.serializers\')', async () => {
-  const stream = sink()
-  const expected = Object.assign({
-    err: stdSerializers.err
-  }, parentSerializers)
-  const parent = pino({ serializers: parentSerializers }, stream)
-  const child = parent.child({ a: 'property' })
-
-  assert.deepEqual(parent[Symbol.for('pino.serializers')], expected)
-  assert.deepEqual(child[Symbol.for('pino.serializers')], expected)
-  assert.equal(parent[Symbol.for('pino.serializers')], child[Symbol.for('pino.serializers')])
-
-  const child2 = parent.child({}, {
-    serializers: {
-      a
-    }
-  })
-
-  function a () {
-    return 'hello'
-  }
-
-  // eslint-disable-next-line eqeqeq
-  assert.equal(child2[Symbol.for('pino.serializers')] != parentSerializers, true)
-  assert.equal(child2[Symbol.for('pino.serializers')].a, a)
-  assert.equal(child2[Symbol.for('pino.serializers')].test, parentSerializers.test)
-})
-
-test('children inherit parent serializers', async () => {
-  const stream = sink()
-  const parent = pino({ serializers: parentSerializers }, stream)
-
-  const child = parent.child({ a: 'property' })
-  child.fatal({ test: 'test' })
-  const o = await once(stream, 'data')
-  assert.equal(o.test, 'parent')
-})
-
-test('children inherit parent Symbol serializers', async () => {
-  const stream = sink()
-  const symbolSerializers = {
-    [Symbol.for('b')]: b
-  }
-  const expected = Object.assign({
-    err: stdSerializers.err
-  }, symbolSerializers)
-  const parent = pino({ serializers: symbolSerializers }, stream)
-
-  assert.deepEqual(parent[Symbol.for('pino.serializers')], expected)
-
-  const child = parent.child({}, {
-    serializers: {
-      [Symbol.for('a')]: a,
-      a
-    }
-  })
-
-  function a () {
-    return 'hello'
-  }
-
-  function b () {
-    return 'world'
-  }
-
-  assert.deepEqual(child[Symbol.for('pino.serializers')].a, a)
-  assert.deepEqual(child[Symbol.for('pino.serializers')][Symbol.for('b')], b)
-  assert.deepEqual(child[Symbol.for('pino.serializers')][Symbol.for('a')], a)
-})
-
-test('children serializers get called', async () => {
-  const stream = sink()
-  const parent = pino({
-    test: 'this'
-  }, stream)
-
-  const child = parent.child({ a: 'property' }, { serializers: childSerializers })
-
-  child.fatal({ test: 'test' })
-  const o = await once(stream, 'data')
-  assert.equal(o.test, 'child')
-})
-
-test('children serializers get called when inherited from parent', async () => {
-  const stream = sink()
-  const parent = pino({
-    test: 'this',
-    serializers: parentSerializers
-  }, stream)
-
-  const child = parent.child({}, { serializers: { test: function () { return 'pass' } } })
-
-  child.fatal({ test: 'fail' })
-  const o = await once(stream, 'data')
-  assert.equal(o.test, 'pass')
-})
-
-test('non-overridden serializers are available in the children', async () => {
-  const stream = sink()
-  const pSerializers = {
-    onlyParent: function () { return 'parent' },
-    shared: function () { return 'parent' }
-  }
-
-  const cSerializers = {
-    shared: function () { return 'child' },
-    onlyChild: function () { return 'child' }
-  }
-
-  const parent = pino({ serializers: pSerializers }, stream)
-
-  const child = parent.child({}, { serializers: cSerializers })
-
-  const o = once(stream, 'data')
-  child.fatal({ shared: 'test' })
-  assert.equal((await o).shared, 'child')
-  const o2 = once(stream, 'data')
-  child.fatal({ onlyParent: 'test' })
-  assert.equal((await o2).onlyParent, 'parent')
-  const o3 = once(stream, 'data')
-  child.fatal({ onlyChild: 'test' })
-  assert.equal((await o3).onlyChild, 'child')
-  const o4 = once(stream, 'data')
-  parent.fatal({ onlyChild: 'test' })
-  assert.equal((await o4).onlyChild, 'test')
-})
-
-test('custom serializer for messageKey', async () => {
-  const stream = sink()
-  const instance = pino({ serializers: { msg: () => '422' } }, stream)
-
-  const o = { num: NaN }
-  instance.info(o, 42)
-
-  const { msg } = await once(stream, 'data')
-  assert.equal(msg, '422')
-})

package/node_modules/pino/test/stdout-protection.test.js

@@ -1,41 +0,0 @@
-'use strict'
-
-const test = require('node:test')
-const assert = require('node:assert')
-const { join } = require('node:path')
-const { fork } = require('node:child_process')
-const writer = require('flush-write-stream')
-
-const { once } = require('./helper')
-const pino = require('..')
-
-test('do not use SonicBoom is someone tampered with process.stdout.write', async () => {
-  let actual = ''
-  const child = fork(join(__dirname, 'fixtures', 'stdout-hack-protection.js'), { silent: true })
-
-  child.stdout.pipe(writer((s, enc, cb) => {
-    actual += s
-    cb()
-  }))
-  await once(child, 'close')
-  assert.equal(actual.match(/^hack/) != null, true)
-})
-
-test('do not use SonicBoom is someone has passed process.stdout to pino', async () => {
-  const logger = pino(process.stdout)
-  assert.equal(logger[pino.symbols.streamSym], process.stdout)
-})
-
-test('do not crash if process.stdout has no fd', async (t) => {
-  const fd = process.stdout.fd
-  delete process.stdout.fd
-  t.after(function () { process.stdout.fd = fd })
-  pino()
-})
-
-test('use fd=1 if process.stdout has no fd in pino.destination() (worker case)', async (t) => {
-  const fd = process.stdout.fd
-  delete process.stdout.fd
-  t.after(function () { process.stdout.fd = fd })
-  pino.destination()
-})

package/node_modules/pino/test/syncfalse.test.js

@@ -1,186 +0,0 @@
-'use strict'
-
-const test = require('node:test')
-const assert = require('node:assert')
-const os = require('node:os')
-const { promises: { readFile }, createWriteStream } = require('node:fs')
-const { join } = require('node:path')
-const { fork } = require('node:child_process')
-const writer = require('flush-write-stream')
-const {
-  once,
-  getPathToNull,
-  file,
-  watchFileCreated
-} = require('./helper')
-const { promisify } = require('node:util')
-const tspl = require('@matteo.collina/tspl')
-
-const sleep = promisify(setTimeout)
-
-test('asynchronous logging', async (t) => {
-  const now = Date.now
-  const hostname = os.hostname
-  const proc = process
-  global.process = {
-    __proto__: process,
-    pid: 123456
-  }
-  Date.now = () => 1459875739796
-  os.hostname = () => 'abcdefghijklmnopqr'
-  delete require.cache[require.resolve('../')]
-  const pino = require('../')
-  let expected = ''
-  let actual = ''
-  const normal = pino(writer((s, enc, cb) => {
-    expected += s
-    cb()
-  }))
-
-  const dest = createWriteStream(getPathToNull())
-  dest.write = (s) => {
-    actual += s
-  }
-  const asyncLogger = pino(dest)
-
-  let i = 44
-  while (i--) {
-    normal.info('h')
-    asyncLogger.info('h')
-  }
-
-  const expected2 = expected.split('\n')[0]
-  let actual2 = ''
-
-  const child = fork(join(__dirname, '/fixtures/syncfalse.js'), { silent: true })
-  child.stdout.pipe(writer((s, enc, cb) => {
-    actual2 += s
-    cb()
-  }))
-  await once(child, 'close')
-  // Wait for the last write to be flushed
-  await sleep(100)
-  assert.equal(actual, expected)
-  assert.equal(actual2.trim(), expected2)
-
-  t.after(() => {
-    os.hostname = hostname
-    Date.now = now
-    global.process = proc
-  })
-})
-
-test('sync false with child', async (t) => {
-  const now = Date.now
-  const hostname = os.hostname
-  const proc = process
-  global.process = {
-    __proto__: process,
-    pid: 123456
-  }
-  Date.now = function () {
-    return 1459875739796
-  }
-  os.hostname = function () {
-    return 'abcdefghijklmnopqr'
-  }
-  delete require.cache[require.resolve('../')]
-  const pino = require('../')
-  let expected = ''
-  let actual = ''
-  const normal = pino(writer((s, enc, cb) => {
-    expected += s
-    cb()
-  })).child({ hello: 'world' })
-
-  const dest = createWriteStream(getPathToNull())
-  dest.write = function (s) {
-    actual += s
-  }
-  const asyncLogger = pino(dest).child({ hello: 'world' })
-
-  let i = 500
-  while (i--) {
-    normal.info('h')
-    asyncLogger.info('h')
-  }
-
-  asyncLogger.flush()
-
-  const expected2 = expected.split('\n')[0]
-  let actual2 = ''
-
-  const child = fork(join(__dirname, '/fixtures/syncfalse-child.js'), { silent: true })
-  child.stdout.pipe(writer((s, enc, cb) => {
-    actual2 += s
-    cb()
-  }))
-  await once(child, 'close')
-  assert.equal(actual, expected)
-  assert.equal(actual2.trim(), expected2)
-
-  t.after(() => {
-    os.hostname = hostname
-    Date.now = now
-    global.process = proc
-  })
-})
-
-test('flush does nothing with sync true (default)', async () => {
-  const instance = require('..')()
-  assert.equal(instance.flush(), undefined)
-})
-
-test('should still call flush callback even when does nothing with sync true (default)', async (t) => {
-  const plan = tspl(t, { plan: 3 })
-  const instance = require('..')()
-  instance.flush((...args) => {
-    plan.ok('flush called')
-    plan.deepEqual(args, [])
-
-    // next tick to make flush not called more than once
-    process.nextTick(() => {
-      plan.ok('flush next tick called')
-    })
-  })
-
-  await plan
-})
-
-test('should call the flush callback when flushed the data for async logger', async () => {
-  const outputPath = file()
-  async function getOutputLogLines () {
-    return (await readFile(outputPath)).toString().trim().split('\n').map(JSON.parse)
-  }
-
-  const pino = require('../')
-
-  const instance = pino({}, pino.destination({
-    dest: outputPath,
-
-    // to make sure it does not flush on its own
-    minLength: 4096
-  }))
-  const flushPromise = promisify(instance.flush).bind(instance)
-
-  instance.info('hello')
-  await flushPromise()
-  await watchFileCreated(outputPath)
-
-  const [firstFlushData] = await getOutputLogLines()
-
-  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()
-  assert.equal(afterLogData.length, 1)
-
-  await flushPromise()
-
-  // Making sure data is not flushed yet
-  const afterSecondFlush = (await getOutputLogLines())[1]
-  assert.equal(afterSecondFlush.msg, 'world')
-})

package/node_modules/pino/test/timestamp-nano.test.js

@@ -1,37 +0,0 @@
-'use strict'
-
-/* eslint no-prototype-builtins: 0 */
-
-const test = require('node:test')
-const assert = require('node:assert')
-
-const { sink, once } = require('./helper')
-
-test('pino.stdTimeFunctions.isoTimeNano returns RFC 3339 timestamps', async () => {
-  // Mock Date.now at module initialization time
-  const now = Date.now
-  Date.now = () => new Date('2025-08-01T15:03:45.000000000Z').getTime()
-
-  // Mock process.hrtime.bigint at module initialization time
-  const hrTimeBigint = process.hrtime.bigint
-  process.hrtime.bigint = () => 100000000000000n
-
-  const pino = require('../')
-
-  const opts = {
-    timestamp: pino.stdTimeFunctions.isoTimeNano
-  }
-  const stream = sink()
-
-  // Mock process.hrtime.bigint at invocation time, add 1 day to the timestamp
-  process.hrtime.bigint = () => 100000000000000n + 86400012345678n
-
-  const instance = pino(opts, stream)
-  instance.info('foobar')
-  const result = await once(stream, 'data')
-  assert.equal(result.hasOwnProperty('time'), true)
-  assert.equal(result.time, '2025-08-02T15:03:45.012345678Z')
-
-  Date.now = now
-  process.hrtime.bigint = hrTimeBigint
-})

package/node_modules/pino/test/timestamp.test.js

@@ -1,124 +0,0 @@
-'use strict'
-
-/* eslint no-prototype-builtins: 0 */
-
-const test = require('node:test')
-const assert = require('node:assert')
-
-const { sink, once } = require('./helper')
-const pino = require('../')
-
-test('pino exposes standard time functions', async () => {
-  assert.ok(pino.stdTimeFunctions)
-  assert.ok(pino.stdTimeFunctions.epochTime)
-  assert.ok(pino.stdTimeFunctions.unixTime)
-  assert.ok(pino.stdTimeFunctions.nullTime)
-  assert.ok(pino.stdTimeFunctions.isoTime)
-  assert.ok(pino.stdTimeFunctions.isoTimeNano)
-})
-
-test('pino accepts external time functions', async () => {
-  const opts = {
-    timestamp: () => ',"time":"none"'
-  }
-  const stream = sink()
-  const instance = pino(opts, stream)
-  instance.info('foobar')
-  const result = await once(stream, 'data')
-  assert.equal(result.hasOwnProperty('time'), true)
-  assert.equal(result.time, 'none')
-})
-
-test('pino accepts external time functions with custom label', async () => {
-  const opts = {
-    timestamp: () => ',"custom-time-label":"none"'
-  }
-  const stream = sink()
-  const instance = pino(opts, stream)
-  instance.info('foobar')
-  const result = await once(stream, 'data')
-  assert.equal(result.hasOwnProperty('custom-time-label'), true)
-  assert.equal(result['custom-time-label'], 'none')
-})
-
-test('inserts timestamp by default', async ({ ok, equal }) => {
-  const stream = sink()
-  const instance = pino(stream)
-  instance.info('foobar')
-  const result = await once(stream, 'data')
-  assert.equal(result.hasOwnProperty('time'), true)
-  assert.ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
-  assert.equal(result.msg, 'foobar')
-})
-
-test('omits timestamp when timestamp option is false', async () => {
-  const stream = sink()
-  const instance = pino({ timestamp: false }, stream)
-  instance.info('foobar')
-  const result = await once(stream, 'data')
-  assert.equal(result.hasOwnProperty('time'), false)
-  assert.equal(result.msg, 'foobar')
-})
-
-test('inserts timestamp when timestamp option is true', async ({ ok, equal }) => {
-  const stream = sink()
-  const instance = pino({ timestamp: true }, stream)
-  instance.info('foobar')
-  const result = await once(stream, 'data')
-  assert.equal(result.hasOwnProperty('time'), true)
-  assert.ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
-  assert.equal(result.msg, 'foobar')
-})
-
-test('child inserts timestamp by default', async ({ ok, equal }) => {
-  const stream = sink()
-  const logger = pino(stream)
-  const instance = logger.child({ component: 'child' })
-  instance.info('foobar')
-  const result = await once(stream, 'data')
-  assert.equal(result.hasOwnProperty('time'), true)
-  assert.ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
-  assert.equal(result.msg, 'foobar')
-})
-
-test('child omits timestamp with option', async () => {
-  const stream = sink()
-  const logger = pino({ timestamp: false }, stream)
-  const instance = logger.child({ component: 'child' })
-  instance.info('foobar')
-  const result = await once(stream, 'data')
-  assert.equal(result.hasOwnProperty('time'), false)
-  assert.equal(result.msg, 'foobar')
-})
-
-test('pino.stdTimeFunctions.unixTime returns seconds based timestamps', async () => {
-  const opts = {
-    timestamp: pino.stdTimeFunctions.unixTime
-  }
-  const stream = sink()
-  const instance = pino(opts, stream)
-  const now = Date.now
-  Date.now = () => 1531069919686
-  instance.info('foobar')
-  const result = await once(stream, 'data')
-  assert.equal(result.hasOwnProperty('time'), true)
-  assert.equal(result.time, 1531069920)
-  Date.now = now
-})
-
-test('pino.stdTimeFunctions.isoTime returns ISO 8601 timestamps', async () => {
-  const opts = {
-    timestamp: pino.stdTimeFunctions.isoTime
-  }
-  const stream = sink()
-  const instance = pino(opts, stream)
-  const ms = 1531069919686
-  const now = Date.now
-  Date.now = () => ms
-  const iso = new Date(ms).toISOString()
-  instance.info('foobar')
-  const result = await once(stream, 'data')
-  assert.equal(result.hasOwnProperty('time'), true)
-  assert.equal(result.time, iso)
-  Date.now = now
-})

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

@@ -1,42 +0,0 @@
-'use strict'
-
-const test = require('node:test')
-const assert = require('node:assert')
-const { join } = require('node:path')
-const { createReadStream } = require('node:fs')
-const { promisify } = require('node:util')
-const stream = require('node:stream')
-const execa = require('execa')
-const split = require('split2')
-
-const { file } = require('../helper')
-
-const pipeline = promisify(stream.pipeline)
-const { Writable } = stream
-const sleep = promisify(setTimeout)
-
-const skip = process.env.CI || process.env.CITGM
-
-test('eight million lines', { skip }, async () => {
-  const destination = file()
-  await execa(process.argv[0], [join(__dirname, '..', 'fixtures', 'transport-many-lines.js'), destination])
-
-  if (process.platform !== 'win32') {
-    try {
-      await execa('sync') // Wait for the file to be written to disk
-    } catch {
-      // Just a fallback, this should be unreachable
-    }
-  }
-  await sleep(1_000) // It seems that sync is not enough (even in POSIX systems)
-
-  const toWrite = 8 * 1_000_000
-  let count = 0
-  await pipeline(createReadStream(destination), split(), new Writable({
-    write (chunk, enc, cb) {
-      count++
-      cb()
-    }
-  }))
-  assert.equal(count, toWrite)
-})