@farthershore/cli 0.3.9 → 0.3.10

package/node_modules/pino-abstract-transport/test/worker.test.js

@@ -0,0 +1,372 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { once } = require('node:events')
+const { join } = require('node:path')
+const { MessageChannel } = require('node:worker_threads')
+const ThreadStream = require('thread-stream')
+const tspl = require('@matteo.collina/tspl')
+
+const match = require('./match')
+
+workerTest('transport-on-data.js')
+workerTest('transport-async-iteration.js', ' when using async iteration')
+
+function workerTest (filename, description = '') {
+  test(`does not wait for pino to send config by default${description}`, async function (t) {
+    const plan = tspl(t, { plan: 4 })
+    const { port1, port2 } = new MessageChannel()
+    const stream = new ThreadStream({
+      filename: join(__dirname, 'fixtures', filename),
+      workerData: { port: port1 },
+      workerOpts: {
+        transferList: [port1]
+      }
+    })
+
+    const expected = [{
+      level: 30,
+      time: 1617955768092,
+      pid: 2942,
+      hostname: 'MacBook-Pro.local',
+      msg: 'hello world'
+    }, {
+      level: 30,
+      time: 1617955768092,
+      pid: 2942,
+      hostname: 'MacBook-Pro.local',
+      msg: 'another message',
+      prop: 42
+    }]
+
+    const emptyPinoConfig = {
+      levels: undefined,
+      messageKey: undefined,
+      errorKey: undefined
+    }
+
+    port2.on('message', function (message) {
+      match(expected.shift(), message.data, { assert: plan })
+      match(emptyPinoConfig, message.pinoConfig, { assert: plan })
+    })
+
+    const lines = expected.map(JSON.stringify).join('\n')
+    stream.write(lines)
+    stream.end()
+
+    await plan
+  })
+
+  test(`does not wait for pino to send config if transport is not expecting it${description}`, async function (t) {
+    const plan = tspl(t, { plan: 4 })
+    const { port1, port2 } = new MessageChannel()
+    const stream = new ThreadStream({
+      filename: join(__dirname, 'fixtures', filename),
+      workerData: {
+        port: port1,
+        pinoWillSendConfig: true
+      },
+      workerOpts: {
+        transferList: [port1]
+      }
+    })
+
+    const expected = [{
+      level: 30,
+      time: 1617955768092,
+      pid: 2942,
+      hostname: 'MacBook-Pro.local',
+      msg: 'hello world'
+    }, {
+      level: 30,
+      time: 1617955768092,
+      pid: 2942,
+      hostname: 'MacBook-Pro.local',
+      msg: 'another message',
+      prop: 42
+    }]
+
+    const emptyPinoConfig = {
+      levels: undefined,
+      messageKey: undefined,
+      errorKey: undefined
+    }
+
+    const pinoConfig = {
+      levels: {
+        labels: { 30: 'info' },
+        values: { info: 30 }
+      },
+      messageKey: 'msg',
+      errorKey: 'err'
+    }
+
+    stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
+
+    port2.on('message', function (message) {
+      match(expected.shift(), message.data, { assert: plan })
+      match(emptyPinoConfig, message.pinoConfig, { assert: plan })
+    })
+
+    const lines = expected.map(JSON.stringify).join('\n')
+    stream.write(lines)
+    stream.end()
+
+    await plan
+  })
+
+  test(`waits for the pino config when pino intends to send it and the transport requests it${description}`, async function (t) {
+    const plan = tspl(t, { plan: 4 })
+    const { port1, port2 } = new MessageChannel()
+    const stream = new ThreadStream({
+      filename: join(__dirname, 'fixtures', filename),
+      workerData: {
+        port: port1,
+        pinoWillSendConfig: true,
+        opts: {
+          expectPinoConfig: true
+        }
+      },
+      workerOpts: {
+        transferList: [port1]
+      }
+    })
+
+    const expected = [{
+      level: 30,
+      time: 1617955768092,
+      pid: 2942,
+      hostname: 'MacBook-Pro.local',
+      msg: 'hello world'
+    }, {
+      level: 30,
+      time: 1617955768092,
+      pid: 2942,
+      hostname: 'MacBook-Pro.local',
+      msg: 'another message',
+      prop: 42
+    }]
+
+    const pinoConfig = {
+      levels: {
+        labels: { 30: 'info' },
+        values: { info: 30 }
+      },
+      messageKey: 'msg',
+      errorKey: 'err'
+    }
+
+    port2.on('message', function (message) {
+      match(expected.shift(), message.data, { assert: plan })
+      match(pinoConfig, message.pinoConfig, { assert: plan })
+    })
+
+    const lines = expected.map(JSON.stringify).join('\n')
+    stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
+    stream.write(lines)
+    stream.end()
+
+    await plan
+  })
+
+  test(`continues to listen if it receives a message that is not PINO_CONFIG${description}`, async function (t) {
+    const plan = tspl(t, { plan: 4 })
+    const { port1, port2 } = new MessageChannel()
+    const stream = new ThreadStream({
+      filename: join(__dirname, 'fixtures', 'transport-on-data.js'),
+      workerData: {
+        port: port1,
+        pinoWillSendConfig: true,
+        opts: {
+          expectPinoConfig: true
+        }
+      },
+      workerOpts: {
+        transferList: [port1]
+      }
+    })
+
+    const expected = [{
+      level: 30,
+      time: 1617955768092,
+      pid: 2942,
+      hostname: 'MacBook-Pro.local',
+      msg: 'hello world'
+    }, {
+      level: 30,
+      time: 1617955768092,
+      pid: 2942,
+      hostname: 'MacBook-Pro.local',
+      msg: 'another message',
+      prop: 42
+    }]
+
+    const pinoConfig = {
+      levels: {
+        labels: { 30: 'info' },
+        values: { info: 30 }
+      },
+      messageKey: 'msg',
+      errorKey: 'err'
+    }
+
+    port2.on('message', function (message) {
+      match(expected.shift(), message.data, { assert: plan })
+      match(pinoConfig, message.pinoConfig, { assert: plan })
+    })
+
+    const lines = expected.map(JSON.stringify).join('\n')
+    stream.emit('message', 'not a PINO_CONFIG')
+    stream.emit('message', { code: 'NOT_PINO_CONFIG', config: { levels: 'foo', messageKey: 'bar', errorKey: 'baz' } })
+    stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
+    stream.write(lines)
+    stream.end()
+
+    await plan
+  })
+
+  test(`waits for the pino config even if it is sent after write${description}`, async function (t) {
+    const plan = tspl(t, { plan: 4 })
+    const { port1, port2 } = new MessageChannel()
+    const stream = new ThreadStream({
+      filename: join(__dirname, 'fixtures', filename),
+      workerData: {
+        port: port1,
+        pinoWillSendConfig: true,
+        opts: {
+          expectPinoConfig: true
+        }
+      },
+      workerOpts: {
+        transferList: [port1]
+      }
+    })
+
+    const expected = [{
+      level: 30,
+      time: 1617955768092,
+      pid: 2942,
+      hostname: 'MacBook-Pro.local',
+      msg: 'hello world'
+    }, {
+      level: 30,
+      time: 1617955768092,
+      pid: 2942,
+      hostname: 'MacBook-Pro.local',
+      msg: 'another message',
+      prop: 42
+    }]
+
+    const pinoConfig = {
+      levels: {
+        labels: { 30: 'info' },
+        values: { info: 30 }
+      },
+      messageKey: 'msg',
+      errorKey: 'err'
+    }
+
+    port2.on('message', function (message) {
+      match(expected.shift(), message.data, { assert: plan })
+      match(pinoConfig, message.pinoConfig, { assert: plan })
+    })
+
+    const lines = expected.map(JSON.stringify).join('\n')
+    stream.write(lines)
+    stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
+    stream.end()
+
+    await plan
+  })
+
+  test(`emits an error if the transport expects pino to send the config, but pino is not going to${description}`, async function () {
+    const stream = new ThreadStream({
+      filename: join(__dirname, 'fixtures', filename),
+      workerData: {
+        opts: {
+          expectPinoConfig: true
+        }
+      }
+    })
+    const [err] = await once(stream, 'error')
+    assert.equal(err.message, 'This transport is not compatible with the current version of pino. Please upgrade pino to the latest version.')
+    assert.ok(stream.destroyed)
+  })
+}
+
+test('waits for the pino config when pipelining', async function (t) {
+  const plan = tspl(t, { plan: 2 })
+  const { port1, port2 } = new MessageChannel()
+  const stream = new ThreadStream({
+    filename: join(__dirname, 'fixtures', 'worker-pipeline.js'),
+    workerData: {
+      pinoWillSendConfig: true,
+      targets: [{
+        target: './transport-transform.js',
+        options: {
+          opts: { expectPinoConfig: true }
+        }
+      }, {
+        target: './transport-on-data.js',
+        options: {
+          port: port1
+        }
+      }]
+    },
+    workerOpts: {
+      transferList: [port1]
+    }
+  })
+
+  const expected = [{
+    level: 'info(30)',
+    time: 1617955768092,
+    pid: 2942,
+    hostname: 'MacBook-Pro.local',
+    msg: 'HELLO WORLD',
+    service: 'from transform'
+  }, {
+    level: 'info(30)',
+    time: 1617955768092,
+    pid: 2942,
+    hostname: 'MacBook-Pro.local',
+    msg: 'ANOTHER MESSAGE',
+    prop: 42,
+    service: 'from transform'
+  }]
+
+  const lines = [{
+    level: 30,
+    time: 1617955768092,
+    pid: 2942,
+    hostname: 'MacBook-Pro.local',
+    msg: 'hello world'
+  }, {
+    level: 30,
+    time: 1617955768092,
+    pid: 2942,
+    hostname: 'MacBook-Pro.local',
+    msg: 'another message',
+    prop: 42
+  }].map(JSON.stringify).join('\n')
+
+  const pinoConfig = {
+    levels: {
+      labels: { 30: 'info' },
+      values: { info: 30 }
+    },
+    messageKey: 'msg',
+    errorKey: 'err'
+  }
+
+  port2.on('message', function (message) {
+    match(expected.shift(), message.data, { assert: plan })
+  })
+
+  stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
+  stream.write(lines)
+  stream.end()
+
+  await plan
+})

package/node_modules/pino-std-serializers/.editorconfig

@@ -0,0 +1,13 @@
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+
+# [*.md]
+# trim_trailing_whitespace = false

package/node_modules/pino-std-serializers/.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-std-serializers/.github/workflows/ci.yml

@@ -0,0 +1,81 @@
+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@v6
+        with:
+          persist-credentials: false
+
+      - name: Dependency review
+        uses: actions/dependency-review-action@v4
+
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: [18, 20]
+    steps:
+      - name: Check out repo
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - name: Setup Node ${{ matrix.node-version }}
+        uses: actions/setup-node@v6
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Install dependencies
+        run: npm install --ignore-scripts
+        env:
+          NODE_ENV: development
+
+      - name: Lint-CI
+        run: npm run lint-ci
+
+      - name: Test-Types
+        run: npm run test-types
+
+      - name: Test-CI
+        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-std-serializers/LICENSE

@@ -0,0 +1,7 @@
+Copyright Mateo Collina, David Mark Clements, James Sumners
+
+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-std-serializers/Readme.md

@@ -0,0 +1,182 @@
+# pino-std-serializers  [![CI](https://github.com/pinojs/pino-std-serializers/workflows/CI/badge.svg)](https://github.com/pinojs/pino-std-serializers/actions?query=workflow%3ACI)
+
+This module provides a set of standard object serializers for the
+[Pino](https://getpino.io) logger.
+
+## Serializers
+
+### `exports.err(error)`
+Serializes an `Error` like object. Returns an object:
+
+```js
+{
+  type: 'string', // The name of the object's constructor.
+  message: 'string', // The supplied error message.
+  stack: 'string', // The stack when the error was generated.
+  raw: Error  // Non-enumerable, i.e. will not be in the output, original
+              // Error object. This is available for subsequent serializers
+              // to use.
+  [...any additional Enumerable property the original Error had]
+}
+```
+
+Any other extra properties, e.g. `statusCode`, that have been attached to the
+object will also be present on the serialized object.
+
+If the error object has a [`cause`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause) property, the `cause`'s `message` and `stack` will be appended to the top-level `message` and `stack`. All other parameters that belong to the `error.cause` object will be omitted.
+
+Example:
+
+```js
+const serializer = require('pino-std-serializers').err;
+
+const innerError = new Error("inner error");
+innerError.isInner = true;
+const outerError = new Error("outer error", { cause: innerError });
+outerError.isInner = false;
+
+const serialized = serializer(outerError);
+/* Result:
+{
+  "type": "Error",
+  "message": "outer error: inner error",
+  "isInner": false,
+  "stack": "Error: outer error
+        at <...omitted..>
+    caused by: Error: inner error
+        at <...omitted..>
+}
+ */
+```
+
+### `exports.errWithCause(error)`
+Serializes an `Error` like object, including any `error.cause`. Returns an object:
+
+```js
+{
+  type: 'string', // The name of the object's constructor.
+  message: 'string', // The supplied error message.
+  stack: 'string', // The stack when the error was generated.
+  cause?: Error, // If the original error had an error.cause, it will be serialized here
+  raw: Error  // Non-enumerable, i.e. will not be in the output, original
+              // Error object. This is available for subsequent serializers
+              // to use.
+  [...any additional Enumerable property the original Error had]
+}
+```
+
+Any other extra properties, e.g. `statusCode`, that have been attached to the object will also be present on the serialized object.
+
+Example:
+```javascript
+const serializer = require('pino-std-serializers').errWithCause;
+
+const innerError = new Error("inner error");
+innerError.isInner = true;
+const outerError = new Error("outer error", { cause: innerError });
+outerError.isInner = false;
+
+const serialized = serializer(outerError);
+/* Result:
+{
+  "type": "Error",
+  "message": "outer error",
+  "isInner": false,
+  "stack": "Error: outer error
+    at <...omitted..>",
+  "cause": {
+    "type": "Error",
+    "message": "inner error",
+    "isInner": true,
+    "stack": "Error: inner error
+      at <...omitted..>"
+  },
+}
+ */
+```
+
+### `exports.mapHttpResponse(response)`
+Used internally by Pino for general response logging. Returns an object:
+
+```js
+{
+  res: {}
+}
+```
+
+Where `res` is the `response` as serialized by the standard response serializer.
+
+### `exports.mapHttpRequest(request)`
+Used internall by Pino for general request logging. Returns an object:
+
+```js
+{
+  req: {}
+}
+```
+
+Where `req` is the `request` as serialized by the standard request serializer.
+
+### `exports.req(request)`
+The default `request` serializer. Returns an object:
+
+```js
+{
+  id: 'string', // Defaults to `undefined`, unless there is an `id` property
+                // already attached to the `request` object or to the `request.info`
+                // object. Attach a synchronous function
+                // to the `request.id` that returns an identifier to have
+                // the value filled.
+  method: 'string',
+  url: 'string', // the request pathname (as per req.url in core HTTP)
+  query: 'object', // the request query (as per req.query in express or hapi)
+  params: 'object', // the request params (as per req.params in express or hapi)
+  headers: Object, // a reference to the `headers` object from the request
+                   // (as per req.headers in core HTTP)
+  remoteAddress: 'string',
+  remotePort: Number,
+  raw: Object // Non-enumerable, i.e. will not be in the output, original
+              // request object. This is available for subsequent serializers
+              // to use. In cases where the `request` input already has
+              // a `raw` property this will replace the original `request.raw`
+              // property
+}
+```
+
+### `exports.res(response)`
+The default `response` serializer. Returns an object:
+
+```js
+{
+  statusCode: Number, // Response status code, will be null before headers are flushed
+  headers: Object, // The headers to be sent in the response.
+  raw: Object // Non-enumerable, i.e. will not be in the output, original
+              // response object. This is available for subsequent serializers
+              // to use.
+}
+```
+
+### `exports.wrapErrorSerializer(customSerializer)`
+A utility method for wrapping the default error serializer. This allows
+custom serializers to work with the already serialized object.
+
+The `customSerializer` accepts one parameter — the newly serialized error
+object — and returns the new (or updated) error object.
+
+### `exports.wrapRequestSerializer(customSerializer)`
+A utility method for wrapping the default request serializer. This allows
+custom serializers to work with the already serialized object.
+
+The `customSerializer` accepts one parameter — the newly serialized request
+object — and returns the new (or updated) request object.
+
+### `exports.wrapResponseSerializer(customSerializer)`
+A utility method for wrapping the default response serializer. This allows
+custom serializers to work with the already serialized object.
+
+The `customSerializer` accepts one parameter — the newly serialized response
+object — and returns the new (or updated) response object.
+
+## License
+
+MIT License

package/node_modules/pino-std-serializers/eslint.config.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const neostandard = require('neostandard')
+
+module.exports = neostandard({
+  ignores: neostandard.resolveIgnoresFromGitignore(),
+})