@farthershore/cli 0.3.10 → 0.3.11

package/node_modules/pino/test/fixtures/ts/transpile.cjs

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-
-const execa = require('execa')
-const fs = require('node:fs')
-
-const existsSync = fs.existsSync
-const stat = fs.promises.stat
-
-// Hardcoded parameters
-const esVersions = ['es5', 'es6', 'es2017', 'esnext']
-const filesToTranspile = ['to-file-transport.ts']
-
-async function transpile () {
-  process.chdir(__dirname)
-
-  for (const sourceFileName of filesToTranspile) {
-    const sourceStat = await stat(sourceFileName)
-
-    for (const esVersion of esVersions) {
-      const intermediateFileName = sourceFileName.replace(/\.ts$/, '.js')
-      const targetFileName = sourceFileName.replace(/\.ts$/, `.${esVersion}.cjs`)
-
-      const shouldTranspile = !existsSync(targetFileName) || (await stat(targetFileName)).mtimeMs < sourceStat.mtimeMs
-
-      if (shouldTranspile) {
-        await execa('tsc', ['--target', esVersion, '--module', 'commonjs', sourceFileName])
-        await execa('mv', [intermediateFileName, targetFileName])
-      }
-    }
-  }
-}
-
-transpile().catch(err => {
-  process.exitCode = 1
-  throw err
-})

package/node_modules/pino/test/fixtures/ts/transport-exit-immediately-with-async-dest.ts

@@ -1,15 +0,0 @@
-import pino from '../../..'
-import { join } from 'node:path'
-
-const transport = pino.transport({
-  target: join(__dirname, 'to-file-transport-with-transform.ts'),
-  options: {
-    destination: process.argv[2]
-  }
-})
-const logger = pino(transport)
-
-logger.info('Hello')
-logger.info('World')
-
-process.exit(0)

package/node_modules/pino/test/fixtures/ts/transport-exit-immediately.ts

@@ -1,10 +0,0 @@
-import pino from '../../..'
-
-const transport = pino.transport({
-  target: 'pino/file'
-})
-const logger = pino(transport)
-
-logger.info('Hello')
-
-process.exit(0)

package/node_modules/pino/test/fixtures/ts/transport-exit-on-ready.ts

@@ -1,11 +0,0 @@
-import pino from '../../..'
-
-const transport = pino.transport({
-  target: 'pino/file'
-})
-const logger = pino(transport)
-
-transport.on('ready', function () {
-  logger.info('Hello')
-  process.exit(0)
-})

package/node_modules/pino/test/fixtures/ts/transport-main.ts

@@ -1,8 +0,0 @@
-import { join } from 'node:path'
-import pino from '../../..'
-
-const transport = pino.transport({
-  target: join(__dirname, 'transport-worker.ts')
-})
-const logger = pino(transport)
-logger.info('Hello')

package/node_modules/pino/test/fixtures/ts/transport-string-stdout.ts

@@ -1,8 +0,0 @@
-import pino from '../../..'
-
-const transport = pino.transport({
-  target: 'pino/file',
-  options: { destination: '1' }
-})
-const logger = pino(transport)
-logger.info('Hello')

package/node_modules/pino/test/fixtures/ts/transport-worker.ts

@@ -1,14 +0,0 @@
-import { Writable } from 'node:stream'
-
-export default (): Writable => {
-  const myTransportStream = new Writable({
-    autoDestroy: true,
-    write (chunk, _enc, cb) {
-      console.log(chunk.toString())
-      cb()
-    },
-    defaultEncoding: 'utf8'
-  })
-
-  return myTransportStream
-}

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

@@ -1,364 +0,0 @@
-'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 tspl = require('@matteo.collina/tspl')
-
-const { sink, match, once, watchFileCreated, file } = require('./helper')
-const pino = require('../')
-
-test('level formatter', async () => {
-  const stream = sink()
-  const logger = pino({
-    formatters: {
-      level (label, number) {
-        return {
-          log: {
-            level: label
-          }
-        }
-      }
-    }
-  }, stream)
-
-  const o = once(stream, 'data')
-  logger.info('hello world')
-  match(await o, {
-    log: {
-      level: 'info'
-    }
-  })
-})
-
-test('bindings formatter', async () => {
-  const stream = sink()
-  const logger = pino({
-    formatters: {
-      bindings (bindings) {
-        return {
-          process: {
-            pid: bindings.pid
-          },
-          host: {
-            name: bindings.hostname
-          }
-        }
-      }
-    }
-  }, stream)
-
-  const o = once(stream, 'data')
-  logger.info('hello world')
-  match(await o, {
-    process: {
-      pid: process.pid
-    },
-    host: {
-      name: hostname()
-    }
-  })
-})
-
-test('no bindings formatter', async () => {
-  const stream = sink()
-  const logger = pino({
-    formatters: {
-      bindings (bindings) {
-        return null
-      }
-    }
-  }, stream)
-
-  const o = once(stream, 'data')
-  logger.info('hello world')
-  const log = await o
-  assert.equal(log.hasOwnProperty('pid'), false)
-  assert.equal(log.hasOwnProperty('hostname'), false)
-  match(log, { msg: 'hello world' })
-})
-
-test('log formatter', async (t) => {
-  const plan = tspl(t, { plan: 1 })
-  const stream = sink()
-  const logger = pino({
-    formatters: {
-      log (obj) {
-        plan.equal(obj.hasOwnProperty('msg'), false)
-        return { hello: 'world', ...obj }
-      }
-    }
-  }, stream)
-
-  const o = once(stream, 'data')
-  logger.info({ foo: 'bar', nested: { object: true } }, 'hello world')
-  match(await o, {
-    hello: 'world',
-    foo: 'bar',
-    nested: { object: true }
-  })
-
-  await plan
-})
-
-test('Formatters combined', async () => {
-  const stream = sink()
-  const logger = pino({
-    formatters: {
-      level (label, number) {
-        return {
-          log: {
-            level: label
-          }
-        }
-      },
-      bindings (bindings) {
-        return {
-          process: {
-            pid: bindings.pid
-          },
-          host: {
-            name: bindings.hostname
-          }
-        }
-      },
-      log (obj) {
-        return { hello: 'world', ...obj }
-      }
-    }
-  }, stream)
-
-  const o = once(stream, 'data')
-  logger.info({ foo: 'bar', nested: { object: true } }, 'hello world')
-  match(await o, {
-    log: {
-      level: 'info'
-    },
-    process: {
-      pid: process.pid
-    },
-    host: {
-      name: hostname()
-    },
-    hello: 'world',
-    foo: 'bar',
-    nested: { object: true }
-  })
-})
-
-test('Formatters in child logger', async () => {
-  const stream = sink()
-  const logger = pino({
-    formatters: {
-      level (label, number) {
-        return {
-          log: {
-            level: label
-          }
-        }
-      },
-      bindings (bindings) {
-        return {
-          process: {
-            pid: bindings.pid
-          },
-          host: {
-            name: bindings.hostname
-          }
-        }
-      },
-      log (obj) {
-        return { hello: 'world', ...obj }
-      }
-    }
-  }, stream)
-
-  const child = logger.child({
-    foo: 'bar',
-    nested: { object: true }
-  }, {
-    formatters: {
-      bindings (bindings) {
-        return { ...bindings, faz: 'baz' }
-      }
-    }
-  })
-
-  const o = once(stream, 'data')
-  child.info('hello world')
-  match(await o, {
-    log: {
-      level: 'info'
-    },
-    process: {
-      pid: process.pid
-    },
-    host: {
-      name: hostname()
-    },
-    hello: 'world',
-    foo: 'bar',
-    nested: { object: true },
-    faz: 'baz'
-  })
-})
-
-test('Formatters without bindings in child logger', async () => {
-  const stream = sink()
-  const logger = pino({
-    formatters: {
-      level (label, number) {
-        return {
-          log: {
-            level: label
-          }
-        }
-      },
-      bindings (bindings) {
-        return {
-          process: {
-            pid: bindings.pid
-          },
-          host: {
-            name: bindings.hostname
-          }
-        }
-      },
-      log (obj) {
-        return { hello: 'world', ...obj }
-      }
-    }
-  }, stream)
-
-  const child = logger.child({
-    foo: 'bar',
-    nested: { object: true }
-  }, {
-    formatters: {
-      log (obj) {
-        return { other: 'stuff', ...obj }
-      }
-    }
-  })
-
-  const o = once(stream, 'data')
-  child.info('hello world')
-  match(await o, {
-    log: {
-      level: 'info'
-    },
-    process: {
-      pid: process.pid
-    },
-    host: {
-      name: hostname()
-    },
-    foo: 'bar',
-    other: 'stuff',
-    nested: { object: true }
-  })
-})
-
-test('elastic common schema format', async () => {
-  const stream = sink()
-  const ecs = {
-    formatters: {
-      level (label, number) {
-        return {
-          log: {
-            level: label,
-            logger: 'pino'
-          }
-        }
-      },
-      bindings (bindings) {
-        return {
-          process: {
-            pid: bindings.pid
-          },
-          host: {
-            name: bindings.hostname
-          }
-        }
-      },
-      log (obj) {
-        return { ecs: { version: '1.4.0' }, ...obj }
-      }
-    },
-    messageKey: 'message',
-    timestamp: () => `,"@timestamp":"${new Date(Date.now()).toISOString()}"`
-  }
-
-  const logger = pino({ ...ecs }, stream)
-
-  const o = once(stream, 'data')
-  logger.info({ foo: 'bar' }, 'hello world')
-  const log = await o
-  assert.equal(typeof log['@timestamp'], 'string')
-  match(log, {
-    log: { level: 'info', logger: 'pino' },
-    process: { pid: process.pid },
-    host: { name: hostname() },
-    ecs: { version: '1.4.0' },
-    foo: 'bar',
-    message: 'hello world'
-  })
-})
-
-test('formatter with transport', async (t) => {
-  const plan = tspl(t, { plan: 1 })
-  const destination = file()
-  const logger = pino({
-    formatters: {
-      log (obj) {
-        plan.equal(obj.hasOwnProperty('msg'), false)
-        return { hello: 'world', ...obj }
-      }
-    },
-    transport: {
-      targets: [
-        {
-          target: join(__dirname, 'fixtures', 'to-file-transport.js'),
-          options: { destination }
-        }
-      ]
-    }
-  })
-
-  logger.info({ foo: 'bar', nested: { object: true } }, 'hello world')
-  await watchFileCreated(destination)
-  const result = JSON.parse(await readFile(destination))
-  delete result.time
-  match(result, {
-    hello: 'world',
-    foo: 'bar',
-    nested: { object: true }
-  })
-})
-
-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')
-  )
-})

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

@@ -1,4 +0,0 @@
-import type { PathLike } from 'node:fs'
-
-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,155 +0,0 @@
-'use strict'
-
-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 pid = process.pid
-const hostname = os.hostname()
-const { tmpdir } = os
-
-const isWin = process.platform === 'win32'
-const isYarnPnp = process.versions.pnp !== undefined
-
-function getPathToNull () {
-  return isWin ? '\\\\.\\NUL' : '/dev/null'
-}
-
-function once (emitter, name) {
-  return new Promise((resolve, reject) => {
-    if (name !== 'error') emitter.once('error', reject)
-    emitter.once(name, (...args) => {
-      emitter.removeListener('error', reject)
-      resolve(...args)
-    })
-  })
-}
-
-function sink (func) {
-  const result = split((data) => {
-    try {
-      return JSON.parse(data)
-    } catch (err) {
-      console.log(err)
-      console.log(data)
-    }
-  })
-  if (func) result.pipe(writer.obj(func))
-  return result
-}
-
-function check (is, chunk, level, msg) {
-  is(new Date(chunk.time) <= new Date(), true, 'time is greater than Date.now()')
-  delete chunk.time
-  is(chunk.pid, pid)
-  is(chunk.hostname, hostname)
-  is(chunk.level, level)
-  is(chunk.msg, msg)
-}
-
-function sleep (ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms)
-  })
-}
-
-function watchFileCreated (filename) {
-  return new Promise((resolve, reject) => {
-    const TIMEOUT = process.env.PINO_TEST_WAIT_WATCHFILE_TIMEOUT || 10000
-    const INTERVAL = 100
-    const threshold = TIMEOUT / INTERVAL
-    let counter = 0
-    const interval = setInterval(() => {
-      const exists = existsSync(filename)
-      // On some CI runs file is created but not filled
-      if (exists && statSync(filename).size !== 0) {
-        clearInterval(interval)
-        resolve()
-      } else if (counter <= threshold) {
-        counter++
-      } else {
-        clearInterval(interval)
-        reject(new Error(
-          `${filename} hasn't been created within ${TIMEOUT} ms. ` +
-          (exists ? 'File exist, but still empty.' : 'File not yet created.')
-        ))
-      }
-    }, INTERVAL)
-  })
-}
-
-function watchForWrite (filename, testString) {
-  return new Promise((resolve, reject) => {
-    const TIMEOUT = process.env.PINO_TEST_WAIT_WRITE_TIMEOUT || 10000
-    const INTERVAL = 100
-    const threshold = TIMEOUT / INTERVAL
-    let counter = 0
-    const interval = setInterval(() => {
-      if (readFileSync(filename).includes(testString)) {
-        clearInterval(interval)
-        resolve()
-      } else if (counter <= threshold) {
-        counter++
-      } else {
-        clearInterval(interval)
-        reject(new Error(`'${testString}' hasn't been written to ${filename} within ${TIMEOUT} ms.`))
-      }
-    }, INTERVAL)
-  })
-}
-
-let files = []
-
-function file () {
-  const hash = crypto.randomBytes(12).toString('hex')
-  const file = join(tmpdir(), `pino-${pid}-${hash}`)
-  files.push(file)
-  return file
-}
-
-process.on('beforeExit', () => {
-  if (files.length === 0) return
-  for (const file of files) {
-    try {
-      unlinkSync(file)
-    } catch (e) {
-    }
-  }
-  files = []
-})
-
-/**
- * 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
-}