valley-baileys 1.0.0

package/node_modules/pino/test/transport/core.test.ts

@@ -0,0 +1,236 @@
+import * as os from 'node:os'
+import { join } from 'node:path'
+import { once } from 'node:events'
+import fs from 'node:fs'
+import { watchFileCreated } from '../helper'
+import { test } from 'tap'
+import pino from '../../'
+import * as url from 'node:url'
+import { default as strip } from 'strip-ansi'
+import execa from 'execa'
+import writer from 'flush-write-stream'
+
+if (process.platform === 'win32') {
+  // TODO: Implement .ts files loading support for Windows
+  process.exit()
+}
+
+const readFile = fs.promises.readFile
+const { pid } = process
+const hostname = os.hostname()
+
+test('pino.transport with file', async ({ same, teardown }) => {
+  const destination = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+  const transport = pino.transport({
+    target: join(__dirname, '..', 'fixtures', 'ts', 'to-file-transport.ts'),
+    options: { destination }
+  })
+  teardown(transport.end.bind(transport))
+  const instance = pino(transport)
+  instance.info('hello')
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination, { encoding: 'utf8' }))
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+test('pino.transport with file (no options + error handling)', async ({ equal }) => {
+  const transport = pino.transport({
+    target: join(__dirname, '..', 'fixtures', 'ts', 'to-file-transport.ts')
+  })
+  const [err] = await once(transport, 'error')
+  equal(err.message, 'kaboom')
+})
+
+test('pino.transport with file URL', async ({ same, teardown }) => {
+  const destination = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+  const transport = pino.transport({
+    target: url.pathToFileURL(join(__dirname, '..', 'fixtures', 'ts', 'to-file-transport.ts')).href,
+    options: { destination }
+  })
+  teardown(transport.end.bind(transport))
+  const instance = pino(transport)
+  instance.info('hello')
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination, { encoding: 'utf8' }))
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+test('pino.transport with two files', async ({ same, teardown }) => {
+  const dest1 = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+  const dest2 = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+  const transport = pino.transport({
+    targets: [{
+      level: 'info',
+      target: join(__dirname, '..', 'fixtures', 'ts', 'to-file-transport.ts'),
+      options: { destination: dest1 }
+    }, {
+      level: 'info',
+      target: join(__dirname, '..', 'fixtures', 'ts', 'to-file-transport.ts'),
+      options: { destination: dest2 }
+    }]
+  })
+
+  teardown(transport.end.bind(transport))
+
+  const instance = pino(transport)
+  instance.info('hello')
+
+  await Promise.all([watchFileCreated(dest1), watchFileCreated(dest2)])
+
+  const result1 = JSON.parse(await readFile(dest1, { encoding: 'utf8' }))
+  delete result1.time
+  same(result1, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+  const result2 = JSON.parse(await readFile(dest2, { encoding: 'utf8' }))
+  delete result2.time
+  same(result2, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+test('no transport.end()', async ({ same, teardown }) => {
+  const destination = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+  const transport = pino.transport({
+    target: join(__dirname, '..', 'fixtures', 'ts', 'to-file-transport.ts'),
+    options: { destination }
+  })
+  const instance = pino(transport)
+  instance.info('hello')
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination, { encoding: 'utf8' }))
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+test('autoEnd = false', async ({ equal, same, teardown }) => {
+  const destination = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+  const count = process.listenerCount('exit')
+  const transport = pino.transport({
+    target: join(__dirname, '..', 'fixtures', 'ts', 'to-file-transport.ts'),
+    options: { destination },
+    worker: { autoEnd: false }
+  })
+  teardown(transport.end.bind(transport))
+  await once(transport, 'ready')
+
+  const instance = pino(transport)
+  instance.info('hello')
+
+  await watchFileCreated(destination)
+
+  equal(count, process.listenerCount('exit'))
+
+  const result = JSON.parse(await readFile(destination, { encoding: 'utf8' }))
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+test('stdout in worker', async ({ not }) => {
+  let actual = ''
+  const child = execa(process.argv[0], ['-r', 'ts-node/register', join(__dirname, '..', 'fixtures', 'ts', 'transport-main.ts')])
+
+  child.stdout?.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+  await once(child, 'close')
+  not(strip(actual).match(/Hello/), null)
+})
+
+test('log and exit on ready', async ({ not }) => {
+  let actual = ''
+  const child = execa(process.argv[0], ['-r', 'ts-node/register', join(__dirname, '..', 'fixtures', 'ts', 'transport-exit-on-ready.ts')])
+
+  child.stdout?.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+  await once(child, 'close')
+  not(strip(actual).match(/Hello/), null)
+})
+
+test('log and exit before ready', async ({ not }) => {
+  let actual = ''
+  const child = execa(process.argv[0], ['-r', 'ts-node/register', join(__dirname, '..', 'fixtures', 'ts', 'transport-exit-immediately.ts')])
+
+  child.stdout?.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+  await once(child, 'close')
+  not(strip(actual).match(/Hello/), null)
+})
+
+test('log and exit before ready with async dest', async ({ not }) => {
+  const destination = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+  const child = execa(process.argv[0], ['-r', 'ts-node/register', join(__dirname, '..', 'fixtures', 'ts', 'transport-exit-immediately-with-async-dest.ts'), destination])
+
+  await once(child, 'exit')
+
+  const actual = await readFile(destination, { encoding: 'utf8' })
+
+  not(strip(actual).match(/HELLO/), null)
+  not(strip(actual).match(/WORLD/), null)
+})
+
+test('string integer destination', async ({ not }) => {
+  let actual = ''
+  const child = execa(process.argv[0], ['-r', 'ts-node/register', join(__dirname, '..', 'fixtures', 'ts', 'transport-string-stdout.ts')])
+
+  child.stdout?.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+  await once(child, 'close')
+  not(strip(actual).match(/Hello/), null)
+})

package/node_modules/pino/test/transport/core.transpiled.test.ts

@@ -0,0 +1,112 @@
+import * as os from 'node:os'
+import { join } from 'node:path'
+import fs from 'node:fs'
+import { watchFileCreated } from '../helper'
+import { test } from 'tap'
+import pino from '../../'
+import * as url from 'node:url'
+
+const readFile = fs.promises.readFile
+
+const { pid } = process
+const hostname = os.hostname()
+
+// A subset of the test from core.test.js, we don't need all of them to check for compatibility
+function runTests(esVersion: string): void {
+  test(`(ts -> ${esVersion}) pino.transport with file`, async ({ same, teardown }) => {
+    const destination = join(
+      os.tmpdir(),
+      '_' + Math.random().toString(36).substr(2, 9)
+    )
+    const transport = pino.transport({
+      target: join(__dirname, '..', 'fixtures', 'ts', `to-file-transport.${esVersion}.cjs`),
+      options: { destination }
+    })
+    teardown(transport.end.bind(transport))
+    const instance = pino(transport)
+    instance.info('hello')
+    await watchFileCreated(destination)
+    const result = JSON.parse(await readFile(destination, { encoding: 'utf8' }))
+    delete result.time
+    same(result, {
+      pid,
+      hostname,
+      level: 30,
+      msg: 'hello'
+    })
+  })
+
+  test(`(ts -> ${esVersion}) pino.transport with file URL`, async ({ same, teardown }) => {
+    const destination = join(
+      os.tmpdir(),
+      '_' + Math.random().toString(36).substr(2, 9)
+    )
+    const transport = pino.transport({
+      target: url.pathToFileURL(join(__dirname, '..', 'fixtures', 'ts', `to-file-transport.${esVersion}.cjs`)).href,
+      options: { destination }
+    })
+    teardown(transport.end.bind(transport))
+    const instance = pino(transport)
+    instance.info('hello')
+    await watchFileCreated(destination)
+    const result = JSON.parse(await readFile(destination, { encoding: 'utf8' }))
+    delete result.time
+    same(result, {
+      pid,
+      hostname,
+      level: 30,
+      msg: 'hello'
+    })
+  })
+
+  test(`(ts -> ${esVersion}) pino.transport with two files`, async ({ same, teardown }) => {
+    const dest1 = join(
+      os.tmpdir(),
+      '_' + Math.random().toString(36).substr(2, 9)
+    )
+    const dest2 = join(
+      os.tmpdir(),
+      '_' + Math.random().toString(36).substr(2, 9)
+    )
+    const transport = pino.transport({
+      targets: [{
+        level: 'info',
+        target: join(__dirname, '..', 'fixtures', 'ts', `to-file-transport.${esVersion}.cjs`),
+        options: { destination: dest1 }
+      }, {
+        level: 'info',
+        target: join(__dirname, '..', 'fixtures', 'ts', `to-file-transport.${esVersion}.cjs`),
+        options: { destination: dest2 }
+      }]
+    })
+
+    teardown(transport.end.bind(transport))
+
+    const instance = pino(transport)
+    instance.info('hello')
+
+    await Promise.all([watchFileCreated(dest1), watchFileCreated(dest2)])
+
+    const result1 = JSON.parse(await readFile(dest1, { encoding: 'utf8' }))
+    delete result1.time
+    same(result1, {
+      pid,
+      hostname,
+      level: 30,
+      msg: 'hello'
+    })
+    const result2 = JSON.parse(await readFile(dest2, { encoding: 'utf8' }))
+    delete result2.time
+    same(result2, {
+      pid,
+      hostname,
+      level: 30,
+      msg: 'hello'
+    })
+  })
+}
+
+runTests('es5')
+runTests('es6')
+runTests('es2017')
+runTests('esnext')

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

@@ -0,0 +1,34 @@
+'use strict'
+
+const { join } = require('node:path')
+const { once } = require('node:events')
+const { setImmediate: immediate } = require('node:timers/promises')
+const { test } = require('tap')
+const pino = require('../../')
+
+test('pino.transport emits error if the worker exits with 0 unexpectably', async ({ same, teardown, equal }) => {
+  // This test will take 10s, because flushSync waits for 10s
+  const transport = pino.transport({
+    target: join(__dirname, '..', 'fixtures', 'crashing-transport.js'),
+    sync: true
+  })
+  teardown(transport.end.bind(transport))
+
+  await once(transport, 'ready')
+
+  let maybeError
+  transport.on('error', (err) => {
+    maybeError = err
+  })
+
+  const logger = pino(transport)
+  for (let i = 0; i < 100000; i++) {
+    logger.info('hello')
+  }
+
+  await once(transport.worker, 'exit')
+
+  await immediate()
+
+  same(maybeError.message, 'the worker has exited')
+})

package/node_modules/pino/test/transport/module-link.test.js

@@ -0,0 +1,239 @@
+'use strict'
+
+const os = require('node:os')
+const { join } = require('node:path')
+const { readFile, symlink, unlink, mkdir, writeFile } = require('node:fs').promises
+const { test } = require('tap')
+const { isWin, isYarnPnp, watchFileCreated, file } = require('../helper')
+const { once } = require('node:events')
+const execa = require('execa')
+const pino = require('../../')
+const rimraf = require('rimraf')
+
+const { pid } = process
+const hostname = os.hostname()
+
+async function installTransportModule (target) {
+  if (isYarnPnp) {
+    return
+  }
+  try {
+    await uninstallTransportModule()
+  } catch {}
+
+  if (!target) {
+    target = join(__dirname, '..', '..')
+  }
+
+  await symlink(
+    join(__dirname, '..', 'fixtures', 'transport'),
+    join(target, 'node_modules', 'transport')
+  )
+}
+
+async function uninstallTransportModule () {
+  if (isYarnPnp) {
+    return
+  }
+  await unlink(join(__dirname, '..', '..', 'node_modules', 'transport'))
+}
+
+// TODO make this test pass on Windows
+test('pino.transport with package', { skip: isWin }, async ({ same, teardown }) => {
+  const destination = file()
+
+  await installTransportModule()
+
+  const transport = pino.transport({
+    target: 'transport',
+    options: { destination }
+  })
+
+  teardown(async () => {
+    await uninstallTransportModule()
+    transport.end()
+  })
+  const instance = pino(transport)
+  instance.info('hello')
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination))
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+// TODO make this test pass on Windows
+test('pino.transport with package as a target', { skip: isWin }, async ({ same, teardown }) => {
+  const destination = file()
+
+  await installTransportModule()
+
+  const transport = pino.transport({
+    targets: [{
+      target: 'transport',
+      options: { destination }
+    }]
+  })
+  teardown(async () => {
+    await uninstallTransportModule()
+    transport.end()
+  })
+  const instance = pino(transport)
+  instance.info('hello')
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination))
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+// TODO make this test pass on Windows
+test('pino({ transport })', { skip: isWin || isYarnPnp }, async ({ same, teardown }) => {
+  const folder = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+
+  teardown(() => {
+    rimraf.sync(folder)
+  })
+
+  const destination = join(folder, 'output')
+
+  await mkdir(join(folder, 'node_modules'), { recursive: true })
+
+  // Link pino
+  await symlink(
+    join(__dirname, '..', '..'),
+    join(folder, 'node_modules', 'pino')
+  )
+
+  await installTransportModule(folder)
+
+  const toRun = join(folder, 'index.js')
+
+  const toRunContent = `
+    const pino = require('pino')
+    const logger = pino({
+      transport: {
+        target: 'transport',
+        options: { destination: '${destination}' }
+      }
+    })
+    logger.info('hello')
+  `
+
+  await writeFile(toRun, toRunContent)
+
+  const child = execa(process.argv[0], [toRun])
+
+  await once(child, 'close')
+
+  const result = JSON.parse(await readFile(destination))
+  delete result.time
+  same(result, {
+    pid: child.pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+// TODO make this test pass on Windows
+test('pino({ transport }) from a wrapped dependency', { skip: isWin || isYarnPnp }, async ({ same, teardown }) => {
+  const folder = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+
+  const wrappedFolder = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+
+  const destination = join(folder, 'output')
+
+  await mkdir(join(folder, 'node_modules'), { recursive: true })
+  await mkdir(join(wrappedFolder, 'node_modules'), { recursive: true })
+
+  teardown(() => {
+    rimraf.sync(wrappedFolder)
+    rimraf.sync(folder)
+  })
+
+  // Link pino
+  await symlink(
+    join(__dirname, '..', '..'),
+    join(wrappedFolder, 'node_modules', 'pino')
+  )
+
+  // Link get-caller-file
+  await symlink(
+    join(__dirname, '..', '..', 'node_modules', 'get-caller-file'),
+    join(wrappedFolder, 'node_modules', 'get-caller-file')
+  )
+
+  // Link wrapped
+  await symlink(
+    wrappedFolder,
+    join(folder, 'node_modules', 'wrapped')
+  )
+
+  await installTransportModule(folder)
+
+  const pkgjsonContent = {
+    name: 'pino'
+  }
+
+  await writeFile(join(wrappedFolder, 'package.json'), JSON.stringify(pkgjsonContent))
+
+  const wrapped = join(wrappedFolder, 'index.js')
+
+  const wrappedContent = `
+    const pino = require('pino')
+    const getCaller = require('get-caller-file')
+
+    module.exports = function build () {
+      const logger = pino({
+        transport: {
+          caller: getCaller(),
+          target: 'transport',
+          options: { destination: '${destination}' }
+        }
+      })
+      return logger
+    }
+  `
+
+  await writeFile(wrapped, wrappedContent)
+
+  const toRun = join(folder, 'index.js')
+
+  const toRunContent = `
+    const logger = require('wrapped')()
+    logger.info('hello')
+  `
+
+  await writeFile(toRun, toRunContent)
+
+  const child = execa(process.argv[0], [toRun])
+
+  await once(child, 'close')
+
+  const result = JSON.parse(await readFile(destination))
+  delete result.time
+  same(result, {
+    pid: child.pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})