@farthershore/cli 0.3.8 → 0.3.10

package/node_modules/pino-std-serializers/index.d.ts

@@ -0,0 +1,145 @@
+// Type definitions for pino-std-serializers 2.4
+// Definitions by: Connor Fitzgerald <https://github.com/connorjayfitzgerald>
+//                 Igor Savin <https://github.com/kibertoad>
+// TypeScript Version: 2.7
+
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+
+export interface SerializedError {
+  /**
+   * The name of the object's constructor.
+   */
+  type: string;
+  /**
+   * The supplied error message.
+   */
+  message: string;
+  /**
+   * The stack when the error was generated.
+   */
+  stack: string;
+  /**
+   * Non-enumerable. The original Error object. This will not be included in the logged output.
+   * This is available for subsequent serializers to use.
+   */
+  raw: Error;
+  /**
+   * `cause` is never included in the log output, if you need the `cause`, use {@link raw.cause}
+   */
+  cause?: never;
+  /**
+   * Any other extra properties that have been attached to the object will also be present on the serialized object.
+   */
+  [key: string]: any;
+  [key: number]: any;
+}
+
+/**
+ * Serializes an Error object. Does not serialize "err.cause" fields (will append the err.cause.message to err.message
+ * and err.cause.stack to err.stack)
+ */
+export function err(err: Error): SerializedError;
+
+/**
+ * Serializes an Error object, including full serialization for any err.cause fields recursively.
+ */
+export function errWithCause(err: Error): SerializedError;
+
+export interface SerializedRequest {
+  /**
+   * 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.
+   */
+  id: string | undefined;
+  /**
+   * HTTP method.
+   */
+  method: string;
+  /**
+   * Request pathname (as per req.url in core HTTP).
+   */
+  url: string;
+  /**
+   * Reference to the `headers` object from the request (as per req.headers in core HTTP).
+   */
+  headers: Record<string, string>;
+  remoteAddress: string;
+  remotePort: number;
+  params: Record<string, string>;
+  query: Record<string, string>;
+
+  /**
+   * 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.
+   */
+  raw: IncomingMessage;
+}
+
+/**
+ * Serializes a Request object.
+ */
+export function req(req: IncomingMessage): SerializedRequest;
+
+/**
+ * Used internally by Pino for general request logging.
+ */
+export function mapHttpRequest(req: IncomingMessage): {
+  req: SerializedRequest
+};
+
+export interface SerializedResponse {
+  /**
+   * HTTP status code.
+   */
+  statusCode: number;
+  /**
+   * The headers to be sent in the response.
+   */
+  headers: Record<string, string>;
+  /**
+   * Non-enumerable, i.e. will not be in the output, original response object. This is available for subsequent serializers to use.
+   */
+  raw: ServerResponse;
+}
+
+/**
+ * Serializes a Response object.
+ */
+export function res(res: ServerResponse): SerializedResponse;
+
+/**
+ * Used internally by Pino for general response logging.
+ */
+export function mapHttpResponse(res: ServerResponse): {
+  res: SerializedResponse
+};
+
+export type CustomErrorSerializer = (err: SerializedError) => Record<string, any>;
+
+/**
+ * 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.
+ */
+export function wrapErrorSerializer(customSerializer: CustomErrorSerializer): (err: Error) => Record<string, any>;
+
+export type CustomRequestSerializer = (req: SerializedRequest) => Record<string, any>;
+
+/**
+ * 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.
+ */
+export function wrapRequestSerializer(customSerializer: CustomRequestSerializer): (req: IncomingMessage) => Record<string, any>;
+
+export type CustomResponseSerializer = (res: SerializedResponse) => Record<string, any>;
+
+/**
+ * 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.
+ */
+export function wrapResponseSerializer(customSerializer: CustomResponseSerializer): (res: ServerResponse) => Record<string, any>;

package/node_modules/pino-std-serializers/index.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const errSerializer = require('./lib/err')
+const errWithCauseSerializer = require('./lib/err-with-cause')
+const reqSerializers = require('./lib/req')
+const resSerializers = require('./lib/res')
+
+module.exports = {
+  err: errSerializer,
+  errWithCause: errWithCauseSerializer,
+  mapHttpRequest: reqSerializers.mapHttpRequest,
+  mapHttpResponse: resSerializers.mapHttpResponse,
+  req: reqSerializers.reqSerializer,
+  res: resSerializers.resSerializer,
+
+  wrapErrorSerializer: function wrapErrorSerializer (customSerializer) {
+    if (customSerializer === errSerializer) return customSerializer
+    return function wrapErrSerializer (err) {
+      return customSerializer(errSerializer(err))
+    }
+  },
+
+  wrapRequestSerializer: function wrapRequestSerializer (customSerializer) {
+    if (customSerializer === reqSerializers.reqSerializer) return customSerializer
+    return function wrappedReqSerializer (req) {
+      return customSerializer(reqSerializers.reqSerializer(req))
+    }
+  },
+
+  wrapResponseSerializer: function wrapResponseSerializer (customSerializer) {
+    if (customSerializer === resSerializers.resSerializer) return customSerializer
+    return function wrappedResSerializer (res) {
+      return customSerializer(resSerializers.resSerializer(res))
+    }
+  }
+}

package/node_modules/pino-std-serializers/lib/err-helpers.js

@@ -0,0 +1,118 @@
+'use strict'
+
+// **************************************************************
+// * Code initially copied/adapted from "pony-cause" npm module *
+// * Please upstream improvements there                         *
+// **************************************************************
+
+const isErrorLike = (err) => {
+  return err && typeof err.message === 'string'
+}
+
+/**
+ * @param {Error|{ cause?: unknown|(()=>err)}} err
+ * @returns {Error|Object|undefined}
+ */
+const getErrorCause = (err) => {
+  if (!err) return
+
+  /** @type {unknown} */
+  // @ts-ignore
+  const cause = err.cause
+
+  // VError / NError style causes
+  if (typeof cause === 'function') {
+    // @ts-ignore
+    const causeResult = err.cause()
+
+    return isErrorLike(causeResult)
+      ? causeResult
+      : undefined
+  } else {
+    return isErrorLike(cause)
+      ? cause
+      : undefined
+  }
+}
+
+/**
+ * Internal method that keeps a track of which error we have already added, to avoid circular recursion
+ *
+ * @private
+ * @param {Error} err
+ * @param {Set<Error>} seen
+ * @returns {string}
+ */
+const _stackWithCauses = (err, seen) => {
+  if (!isErrorLike(err)) return ''
+
+  const stack = err.stack || ''
+
+  // Ensure we don't go circular or crazily deep
+  if (seen.has(err)) {
+    return stack + '\ncauses have become circular...'
+  }
+
+  const cause = getErrorCause(err)
+
+  if (cause) {
+    seen.add(err)
+    return (stack + '\ncaused by: ' + _stackWithCauses(cause, seen))
+  } else {
+    return stack
+  }
+}
+
+/**
+ * @param {Error} err
+ * @returns {string}
+ */
+const stackWithCauses = (err) => _stackWithCauses(err, new Set())
+
+/**
+ * Internal method that keeps a track of which error we have already added, to avoid circular recursion
+ *
+ * @private
+ * @param {Error} err
+ * @param {Set<Error>} seen
+ * @param {boolean} [skip]
+ * @returns {string}
+ */
+const _messageWithCauses = (err, seen, skip) => {
+  if (!isErrorLike(err)) return ''
+
+  const message = skip ? '' : (err.message || '')
+
+  // Ensure we don't go circular or crazily deep
+  if (seen.has(err)) {
+    return message + ': ...'
+  }
+
+  const cause = getErrorCause(err)
+
+  if (cause) {
+    seen.add(err)
+
+    // @ts-ignore
+    const skipIfVErrorStyleCause = typeof err.cause === 'function'
+
+    return (message +
+      (skipIfVErrorStyleCause ? '' : ': ') +
+      _messageWithCauses(cause, seen, skipIfVErrorStyleCause))
+  } else {
+    return message
+  }
+}
+
+/**
+ * @param {Error} err
+ * @returns {string}
+ */
+const messageWithCauses = (err) => _messageWithCauses(err, new Set())
+
+module.exports = {
+  isErrorLike,
+  getErrorCause,
+  stackWithCauses,
+  messageWithCauses
+}

package/node_modules/pino-std-serializers/lib/err-proto.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const seen = Symbol('circular-ref-tag')
+const rawSymbol = Symbol('pino-raw-err-ref')
+
+const pinoErrProto = Object.create({}, {
+  type: {
+    enumerable: true,
+    writable: true,
+    value: undefined
+  },
+  message: {
+    enumerable: true,
+    writable: true,
+    value: undefined
+  },
+  stack: {
+    enumerable: true,
+    writable: true,
+    value: undefined
+  },
+  aggregateErrors: {
+    enumerable: true,
+    writable: true,
+    value: undefined
+  },
+  raw: {
+    enumerable: false,
+    get: function () {
+      return this[rawSymbol]
+    },
+    set: function (val) {
+      this[rawSymbol] = val
+    }
+  }
+})
+Object.defineProperty(pinoErrProto, rawSymbol, {
+  writable: true,
+  value: {}
+})
+
+module.exports = {
+  pinoErrProto,
+  pinoErrorSymbols: {
+    seen,
+    rawSymbol
+  }
+}

package/node_modules/pino-std-serializers/lib/err-with-cause.js

@@ -0,0 +1,48 @@
+'use strict'
+
+module.exports = errWithCauseSerializer
+
+const { isErrorLike } = require('./err-helpers')
+const { pinoErrProto, pinoErrorSymbols } = require('./err-proto')
+const { seen } = pinoErrorSymbols
+
+const { toString } = Object.prototype
+
+function errWithCauseSerializer (err) {
+  if (!isErrorLike(err)) {
+    return err
+  }
+
+  err[seen] = undefined // tag to prevent re-looking at this
+  const _err = Object.create(pinoErrProto)
+  _err.type = toString.call(err.constructor) === '[object Function]'
+    ? err.constructor.name
+    : err.name
+  _err.message = err.message
+  _err.stack = err.stack
+
+  if (Array.isArray(err.errors)) {
+    _err.aggregateErrors = err.errors.map(err => errWithCauseSerializer(err))
+  }
+
+  if (isErrorLike(err.cause) && !Object.prototype.hasOwnProperty.call(err.cause, seen)) {
+    _err.cause = errWithCauseSerializer(err.cause)
+  }
+
+  for (const key in err) {
+    if (_err[key] === undefined) {
+      const val = err[key]
+      if (isErrorLike(val)) {
+        if (!Object.prototype.hasOwnProperty.call(val, seen)) {
+          _err[key] = errWithCauseSerializer(val)
+        }
+      } else {
+        _err[key] = val
+      }
+    }
+  }
+
+  delete err[seen] // clean up tag in case err is serialized again later
+  _err.raw = err
+  return _err
+}

package/node_modules/pino-std-serializers/lib/err.js

@@ -0,0 +1,45 @@
+'use strict'
+
+module.exports = errSerializer
+
+const { messageWithCauses, stackWithCauses, isErrorLike } = require('./err-helpers')
+const { pinoErrProto, pinoErrorSymbols } = require('./err-proto')
+const { seen } = pinoErrorSymbols
+
+const { toString } = Object.prototype
+
+function errSerializer (err) {
+  if (!isErrorLike(err)) {
+    return err
+  }
+
+  err[seen] = undefined // tag to prevent re-looking at this
+  const _err = Object.create(pinoErrProto)
+  _err.type = toString.call(err.constructor) === '[object Function]'
+    ? err.constructor.name
+    : err.name
+  _err.message = messageWithCauses(err)
+  _err.stack = stackWithCauses(err)
+
+  if (Array.isArray(err.errors)) {
+    _err.aggregateErrors = err.errors.map(err => errSerializer(err))
+  }
+
+  for (const key in err) {
+    if (_err[key] === undefined) {
+      const val = err[key]
+      if (isErrorLike(val)) {
+        // We append cause messages and stacks to _err, therefore skipping causes here
+        if (key !== 'cause' && !Object.prototype.hasOwnProperty.call(val, seen)) {
+          _err[key] = errSerializer(val)
+        }
+      } else {
+        _err[key] = val
+      }
+    }
+  }
+
+  delete err[seen] // clean up tag in case err is serialized again later
+  _err.raw = err
+  return _err
+}

package/node_modules/pino-std-serializers/lib/req.js

@@ -0,0 +1,100 @@
+'use strict'
+
+module.exports = {
+  mapHttpRequest,
+  reqSerializer
+}
+
+const rawSymbol = Symbol('pino-raw-req-ref')
+const pinoReqProto = Object.create({}, {
+  id: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  method: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  url: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  query: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  params: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  headers: {
+    enumerable: true,
+    writable: true,
+    value: {}
+  },
+  remoteAddress: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  remotePort: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  raw: {
+    enumerable: false,
+    get: function () {
+      return this[rawSymbol]
+    },
+    set: function (val) {
+      this[rawSymbol] = val
+    }
+  }
+})
+Object.defineProperty(pinoReqProto, rawSymbol, {
+  writable: true,
+  value: {}
+})
+
+function reqSerializer (req) {
+  // req.info is for hapi compat.
+  const connection = req.info || req.socket
+  const _req = Object.create(pinoReqProto)
+  _req.id = (typeof req.id === 'function' ? req.id() : (req.id || (req.info ? req.info.id : undefined)))
+  _req.method = req.method
+  // req.originalUrl is for expressjs compat.
+  if (req.originalUrl) {
+    _req.url = req.originalUrl
+  } else {
+    const path = req.path
+    // path for safe hapi compat.
+    _req.url = typeof path === 'string' ? path : (req.url ? req.url.path || req.url : undefined)
+  }
+
+  if (req.query) {
+    _req.query = req.query
+  }
+
+  if (req.params) {
+    _req.params = req.params
+  }
+
+  _req.headers = req.headers
+  _req.remoteAddress = connection && connection.remoteAddress
+  _req.remotePort = connection && connection.remotePort
+  // req.raw is  for hapi compat/equivalence
+  _req.raw = req.raw || req
+  return _req
+}
+
+function mapHttpRequest (req) {
+  return {
+    req: reqSerializer(req)
+  }
+}

package/node_modules/pino-std-serializers/lib/res.js

@@ -0,0 +1,47 @@
+'use strict'
+
+module.exports = {
+  mapHttpResponse,
+  resSerializer
+}
+
+const rawSymbol = Symbol('pino-raw-res-ref')
+const pinoResProto = Object.create({}, {
+  statusCode: {
+    enumerable: true,
+    writable: true,
+    value: 0
+  },
+  headers: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  raw: {
+    enumerable: false,
+    get: function () {
+      return this[rawSymbol]
+    },
+    set: function (val) {
+      this[rawSymbol] = val
+    }
+  }
+})
+Object.defineProperty(pinoResProto, rawSymbol, {
+  writable: true,
+  value: {}
+})
+
+function resSerializer (res) {
+  const _res = Object.create(pinoResProto)
+  _res.statusCode = res.headersSent ? res.statusCode : null
+  _res.headers = res.getHeaders ? res.getHeaders() : res._headers
+  _res.raw = res
+  return _res
+}
+
+function mapHttpResponse (res) {
+  return {
+    res: resSerializer(res)
+  }
+}

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

@@ -0,0 +1,42 @@
+{
+  "name": "pino-std-serializers",
+  "version": "7.1.0",
+  "description": "A collection of standard object serializers for Pino",
+  "main": "index.js",
+  "type": "commonjs",
+  "types": "index.d.ts",
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "lint-ci": "eslint --max-warnings=0 .",
+    "test": "borp -p 'test/**/*.js'",
+    "test-ci": "borp --coverage -p 'test/**/*.js'",
+    "test-types": "tsc && tsd"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/pinojs/pino-std-serializers.git"
+  },
+  "keywords": [
+    "pino",
+    "logging"
+  ],
+  "author": "James Sumners <james.sumners@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pinojs/pino-std-serializers/issues"
+  },
+  "homepage": "https://github.com/pinojs/pino-std-serializers#readme",
+  "devDependencies": {
+    "@matteo.collina/tspl": "^0.2.0",
+    "@types/node": "^25.0.3",
+    "borp": "^0.21.0",
+    "eslint": "^9.39.2",
+    "neostandard": "^0.12.2",
+    "tsd": "^0.33.0",
+    "typescript": "~5.9.3"
+  },
+  "tsd": {
+    "directory": "test/types"
+  }
+}