@farthershore/cli 0.3.8 → 0.3.10

package/node_modules/pino/test/types/pino.ts

@@ -0,0 +1,91 @@
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import pinoPretty from 'pino-pretty'
+// Test both default ("Pino") and named ("pino") imports.
+import Pino, { type LoggerOptions, type StreamEntry, pino, multistream, transport } from '../../pino'
+
+const destination = join(
+  tmpdir(),
+  '_' + Math.random().toString(36).substr(2, 9)
+)
+
+// Single
+const transport1 = transport({
+  target: 'pino-pretty',
+  options: { some: 'options for', the: 'transport' }
+})
+const logger = pino(transport1)
+logger.setBindings({ some: 'bindings' })
+logger.info('test2')
+logger.flush()
+const loggerDefault = Pino(transport1)
+loggerDefault.setBindings({ some: 'bindings' })
+loggerDefault.info('test2')
+loggerDefault.flush()
+
+const transport2 = transport({
+  target: 'pino-pretty',
+})
+const logger2 = pino(transport2)
+logger2.info('test2')
+const logger2Default = Pino(transport2)
+logger2Default.info('test2')
+
+// Multiple
+
+const transports = transport({
+  targets: [
+    {
+      level: 'info',
+      target: 'pino-pretty',
+      options: { some: 'options for', the: 'transport' }
+    },
+    {
+      level: 'trace',
+      target: 'pino/file',
+      options: { destination }
+    }
+  ]
+})
+const loggerMulti = pino(transports)
+loggerMulti.info('test2')
+
+// custom levels
+
+const customLevels = {
+  customDebug: 1,
+  info: 2,
+  customNetwork: 3,
+  customError: 4,
+}
+
+type CustomLevels = keyof typeof customLevels
+
+const pinoOpts = {
+  useOnlyCustomLevels: true,
+  customLevels,
+  level: 'customDebug',
+} satisfies LoggerOptions
+
+const multistreamOpts = {
+  dedupe: true,
+  levels: customLevels
+}
+
+const streams: StreamEntry<CustomLevels>[] = [
+  { level: 'customDebug', stream: pinoPretty() },
+  { level: 'info', stream: pinoPretty() },
+  { level: 'customNetwork', stream: pinoPretty() },
+  { level: 'customError', stream: pinoPretty() },
+]
+
+const loggerCustomLevel = pino(pinoOpts, multistream(streams, multistreamOpts))
+loggerCustomLevel.customDebug('test3')
+loggerCustomLevel.info('test4')
+loggerCustomLevel.customError('test5')
+loggerCustomLevel.customNetwork('test6')
+const loggerCustomLevelDefault = Pino(pinoOpts, multistream(streams, multistreamOpts))
+loggerCustomLevelDefault.customDebug('test3')
+loggerCustomLevelDefault.info('test4')
+loggerCustomLevelDefault.customError('test5')
+loggerCustomLevelDefault.customNetwork('test6')

package/node_modules/pino/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "lib": [ "es2015", "dom" ],
+    "module": "commonjs",
+    "noEmit": true,
+    "strict": true,
+    "esModuleInterop": true
+  },
+  "exclude": [
+    "./test/types/*.test-d.ts",
+    "./*.d.ts"
+  ]
+}

package/node_modules/pino-abstract-transport/.github/dependabot.yml

@@ -0,0 +1,13 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    open-pull-requests-limit: 10
+
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 10

package/node_modules/pino-abstract-transport/.github/workflows/ci.yml

@@ -0,0 +1,80 @@
+name: CI
+
+on:
+  push:
+    paths-ignore:
+        - 'docs/**'
+        - '*.md'
+  pull_request:
+    paths-ignore:
+        - 'docs/**'
+        - '*.md'
+
+# This allows a subsequently queued workflow run to interrupt previous runs
+concurrency:
+  group: "${{ github.workflow }} @ ${{ github.event.pull_request.head.label || github.head_ref || github.ref }}"
+  cancel-in-progress: true
+
+jobs:
+  dependency-review:
+    name: Dependency Review
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Check out repo
+        uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+
+      - name: Dependency review
+        uses: actions/dependency-review-action@v3
+
+  test:
+    name: Test
+    runs-on: ${{ matrix.os }}
+    permissions:
+      contents: read
+    strategy:
+      matrix:
+        node-version: [20, 22, 24]
+        os: [macos-latest, ubuntu-latest, windows-latest]
+
+    steps:
+      - name: Check out repo
+        uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+
+      - name: Setup Node ${{ matrix.node-version }}
+        uses: actions/setup-node@v5
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Restore cached dependencies
+        uses: actions/cache@v4
+        with:
+          path: node_modules
+          key: node-modules-${{ hashFiles('package.json') }}
+
+      - name: Install dependencies
+        run: npm i --ignore-scripts
+
+      - name: Run Tests
+        run: npm run test-ci
+
+  automerge:
+    name: Automerge Dependabot PRs
+    if: >
+        github.event_name == 'pull_request' &&
+        github.event.pull_request.user.login == 'dependabot[bot]'
+    needs: test
+    permissions:
+      pull-requests: write
+      contents: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: fastify/github-action-merge-dependabot@v3
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}

package/node_modules/pino-abstract-transport/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npm test

package/node_modules/pino-abstract-transport/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 pino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/pino-abstract-transport/README.md

@@ -0,0 +1,171 @@
+# pino-abstract-transport
+[![npm version](https://img.shields.io/npm/v/pino-abstract-transport)](https://www.npmjs.com/package/pino-abstract-transport)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/pinojs/pino-abstract-transport/ci.yml?branch=main)](https://github.com/pinojs/pino-abstract-transport/actions)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
+
+Write Pino transports easily.
+
+## Install
+
+```sh
+npm i pino-abstract-transport
+```
+
+## Usage
+
+```js
+import build from 'pino-abstract-transport'
+
+export default async function (opts) {
+  return build(async function (source) {
+    for await (let obj of source) {
+      console.log(obj)
+    }
+  })
+}
+```
+
+or in CommonJS and streams:
+
+```js
+'use strict'
+
+const build = require('pino-abstract-transport')
+
+module.exports = function (opts) {
+  return build(function (source) {
+    source.on('data', function (obj) {
+      console.log(obj)
+    })
+  })
+}
+```
+
+## Typescript usage
+
+Install the type definitions for node. Make sure the major version of the type definitions matches the node version you are using.
+
+#### Node 16
+
+```sh
+npm i -D @types/node@16
+```
+
+## API
+
+### build(fn, opts) => Stream
+
+Create a [`split2`](http://npm.im/split2) instance and returns it.
+This same instance is also passed to the given function, which is called
+synchronously.
+
+If `opts.transform` is `true`, `pino-abstract-transform` will 
+wrap the split2 instance and the returned stream using [`duplexify`](https://www.npmjs.com/package/duplexify),
+so they can be concatenated into multiple transports.
+
+#### Events emitted
+
+In addition to all events emitted by a [`Readable`](https://nodejs.org/api/stream.html#stream_class_stream_readable)
+stream, it emits the following events:
+
+* `unknown` where an unparsable line is found, both the line and optional error is emitted.
+
+#### Options
+
+* `parse` an option to change to data format passed to build function. When this option is set to `lines`,
+  the data is passed as a string, otherwise the data is passed as an object. Default: `undefined`.
+
+* `close(err, cb)` a function that is called to shutdown the transport. It's called both on error and non-error shutdowns.
+  It can also return a promise. In this case discard the the `cb` argument.
+
+* `parseLine(line)` a function that is used to parse line received from `pino`.
+
+* `expectPinoConfig` a boolean that indicates if the transport expects Pino to add some of its configuration to the stream. Default: `false`.
+
+## Example
+
+### custom parseLine
+
+You can allow custom `parseLine` from users while providing a simple and safe default parseLine.
+
+```js
+'use strict'
+
+const build = require('pino-abstract-transport')
+
+function defaultParseLine (line) {
+  const obj = JSON.parse(line)
+  // property foo will be added on each line
+  obj.foo = 'bar'
+  return obj
+}
+
+module.exports = function (opts) {
+  const parseLine = typeof opts.parseLine === 'function' ? opts.parseLine : defaultParseLine
+  return build(function (source) {
+    source.on('data', function (obj) {
+      console.log(obj)
+    })
+  }, {
+    parseLine: parseLine
+  })
+}
+```
+
+### Stream concatenation / pipeline
+
+You can pipeline multiple transports:
+
+```js
+const build = require('pino-abstract-transport')
+const { Transform, pipeline } = require('stream')
+
+function buildTransform () {
+  return build(function (source) {
+    return new Transform({
+      objectMode: true,
+      autoDestroy: true,
+      transform (line, enc, cb) {
+        line.service = 'bob'
+        cb(null, JSON.stringify(line))
+      }
+    })
+  }, { enablePipelining: true })
+}
+
+function buildDestination () {
+  return build(function (source) {
+    source.on('data', function (obj) {
+      console.log(obj)
+    })
+  })
+}
+
+pipeline(process.stdin, buildTransform(), buildDestination(), function (err) {
+  console.log('pipeline completed!', err)
+})
+```
+
+### Using pino config
+
+Setting `expectPinoConfig` to `true` will make the transport wait for pino to send its configuration before starting to process logs. It will add `levels`, `messageKey` and `errorKey` to the stream.
+
+When used with an incompatible version of pino, the stream will immediately error.
+
+```js
+import build from 'pino-abstract-transport'
+
+export default function (opts) {
+  return build(async function (source) {
+    for await (const obj of source) {
+      console.log(`[${source.levels.labels[obj.level]}]: ${obj[source.messageKey]}`)
+    }
+  }, {
+    expectPinoConfig: true
+  })
+}
+```
+
+## License
+
+MIT

package/node_modules/pino-abstract-transport/index.d.ts

@@ -0,0 +1,122 @@
+// Type definitions for pino-abstract-transport 0.4.0
+// Project: https://github.com/pinojs/pino-abstract-transport#readme
+// Definitions by: Diyar Oktay <https://github.com/windupbird144>
+
+/// <reference types="node" />
+
+import { Transform } from "stream";
+
+type BuildOptions = {
+  /**
+   * `parseLine(line)` a function that is used to parse line received from pino.
+   * @default JSON.parse
+   */
+  parseLine?: (line: string) => unknown;
+
+  /**
+   * `parse` an option to change to data format passed to build function.
+   * @default undefined
+   *
+   */
+  parse?: "lines";
+
+  /**
+   * `close(err, cb)` a function that is called to shutdown the transport.
+   * It's called both on error and non-error shutdowns. It can also return
+   * a promise. In this case discard the the cb argument.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   close: function (err, cb) {
+   *     process.nextTick(cb, err)
+   *   }
+   * }
+   * ```
+   * */
+  close?: (err: Error, cb: Function) => void | Promise<void>;
+
+  /**
+   * `metadata` If set to false, do not add metadata properties to the returned stream
+   */
+  metadata?: false;
+
+  /**
+   * `expectPinoConfig` If set to true, the transport will wait for pino to send its
+   * configuration before starting to process logs.
+   */
+  expectPinoConfig?: boolean;
+};
+
+/**
+ * Pass these options to wrap the split2 stream and
+ * the returned stream into a Duplex
+ */
+type EnablePipelining = BuildOptions & {
+  enablePipelining: true;
+};
+
+/**
+ * Create a split2 instance and returns it. This same instance is also passed
+ * to the given function, which is called after pino has sent its configuration.
+ *
+ * @returns {Promise<Transform>} the split2 instance
+ */
+declare function build(
+  fn: (transform: Transform & build.OnUnknown) => void | Promise<void>,
+  opts: BuildOptions & { expectPinoConfig: true }
+): Promise<Transform & build.OnUnknown>;
+
+/**
+ * Create a split2 instance and returns it. This same instance is also passed
+ * to the given function, which is called synchronously.
+ *
+ * @returns {Transform} the split2 instance
+ */
+declare function build(
+  fn: (transform: Transform & build.OnUnknown) => void | Promise<void>,
+  opts?: BuildOptions
+): Transform & build.OnUnknown;
+
+/**
+ * Creates a split2 instance and passes it to the given function, which is called
+ * after pino has sent its configuration. Then wraps the split2 instance and
+ * the returned stream into a Duplex, so they can be concatenated into multiple
+ * transports.
+ *
+ * @returns {Promise<Transform>} the wrapped split2 instance
+ */
+declare function build(
+  fn: (transform: Transform & build.OnUnknown) => Transform & build.OnUnknown,
+  opts: EnablePipelining & { expectPinoConfig: true }
+): Promise<Transform>;
+
+/**
+ * Creates a split2 instance and passes it to the given function, which is called
+ * synchronously. Then wraps the split2 instance and the returned stream into a
+ * Duplex, so they can be concatenated into multiple transports.
+ *
+ * @returns {Transform} the wrapped split2 instance
+ */
+declare function build(
+  fn: (transform: Transform & build.OnUnknown) => Transform & build.OnUnknown,
+  opts: EnablePipelining
+): Transform;
+
+declare namespace build {
+  export interface OnUnknown {
+    /**
+     * `unknown` is the event emitted where an unparsable line is found
+     *
+     * @param event 'unknown'
+     * @param line the unparsable line
+     * @param error the error that was thrown when parsing the line
+     */
+    on(
+      event: "unknown",
+      listener: (line: string, error: unknown) => void
+    ): void;
+  }
+}
+
+export = build;

package/node_modules/pino-abstract-transport/index.js

@@ -0,0 +1,128 @@
+'use strict'
+
+const metadata = Symbol.for('pino.metadata')
+const split = require('split2')
+const { Duplex } = require('stream')
+const { parentPort, workerData } = require('worker_threads')
+
+function createDeferred () {
+  let resolve
+  let reject
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve
+    reject = _reject
+  })
+  promise.resolve = resolve
+  promise.reject = reject
+  return promise
+}
+
+module.exports = function build (fn, opts = {}) {
+  const waitForConfig = opts.expectPinoConfig === true && workerData?.workerData?.pinoWillSendConfig === true
+  const parseLines = opts.parse === 'lines'
+  const parseLine = typeof opts.parseLine === 'function' ? opts.parseLine : JSON.parse
+  const close = opts.close || defaultClose
+  const stream = split(function (line) {
+    let value
+
+    try {
+      value = parseLine(line)
+    } catch (error) {
+      this.emit('unknown', line, error)
+      return
+    }
+
+    if (value === null) {
+      this.emit('unknown', line, 'Null value ignored')
+      return
+    }
+
+    if (typeof value !== 'object') {
+      value = {
+        data: value,
+        time: Date.now()
+      }
+    }
+
+    if (stream[metadata]) {
+      stream.lastTime = value.time
+      stream.lastLevel = value.level
+      stream.lastObj = value
+    }
+
+    if (parseLines) {
+      return line
+    }
+
+    return value
+  }, { autoDestroy: true })
+
+  stream._destroy = function (err, cb) {
+    const promise = close(err, cb)
+    if (promise && typeof promise.then === 'function') {
+      promise.then(cb, cb)
+    }
+  }
+
+  if (opts.expectPinoConfig === true && workerData?.workerData?.pinoWillSendConfig !== true) {
+    setImmediate(() => {
+      stream.emit('error', new Error('This transport is not compatible with the current version of pino. Please upgrade pino to the latest version.'))
+    })
+  }
+
+  if (opts.metadata !== false) {
+    stream[metadata] = true
+    stream.lastTime = 0
+    stream.lastLevel = 0
+    stream.lastObj = null
+  }
+
+  if (waitForConfig) {
+    let pinoConfig = {}
+    const configReceived = createDeferred()
+    parentPort.on('message', function handleMessage (message) {
+      if (message.code === 'PINO_CONFIG') {
+        pinoConfig = message.config
+        configReceived.resolve()
+        parentPort.off('message', handleMessage)
+      }
+    })
+
+    Object.defineProperties(stream, {
+      levels: {
+        get () { return pinoConfig.levels }
+      },
+      messageKey: {
+        get () { return pinoConfig.messageKey }
+      },
+      errorKey: {
+        get () { return pinoConfig.errorKey }
+      }
+    })
+
+    return configReceived.then(finish)
+  }
+
+  return finish()
+
+  function finish () {
+    let res = fn(stream)
+
+    if (res && typeof res.catch === 'function') {
+      res.catch((err) => {
+        stream.destroy(err)
+      })
+
+      // set it to null to not retain a reference to the promise
+      res = null
+    } else if (opts.enablePipelining && res) {
+      return Duplex.from({ writable: stream, readable: res })
+    }
+
+    return stream
+  }
+}
+
+function defaultClose (err, cb) {
+  process.nextTick(cb, err)
+}

package/node_modules/pino-abstract-transport/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "pino-abstract-transport",
+  "version": "3.0.0",
+  "description": "Write Pino transports easily",
+  "main": "index.js",
+  "scripts": {
+    "prepare": "husky install",
+    "test": "standard | snazzy && borp --check-coverage 'test/*.test.js'  && tsd",
+    "test-ci": "npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pinojs/pino-abstract-transport.git"
+  },
+  "keywords": [
+    "pino",
+    "transport"
+  ],
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pinojs/pino-abstract-transport/issues"
+  },
+  "homepage": "https://github.com/pinojs/pino-abstract-transport#readme",
+  "dependencies": {
+    "split2": "^4.0.0"
+  },
+  "devDependencies": {
+    "@matteo.collina/tspl": "^0.2.0",
+    "@types/node": "^20.1.0",
+    "borp": "^0.20.2",
+    "husky": "^9.0.6",
+    "snazzy": "^9.0.0",
+    "standard": "^17.0.0",
+    "thread-stream": "^3.1.0",
+    "tsd": "^0.31.0"
+  },
+  "tsd": {
+    "directory": "./test/types"
+  }
+}