@wbce/projen-d9 0.0.28 → 0.1.0

package/node_modules/pino-pretty/benchmark.js

@@ -0,0 +1,105 @@
+'use strict'
+
+// We do not expect amazing numbers from `pino-pretty` as the whole purpose
+// of the module is a very slow operation. However, this benchmark should give
+// us some guidance on how features, or code changes, will affect the
+// performance of the module.
+
+const bench = require('fastbench')
+const {
+  prettyFactory
+} = require('./index')
+
+const max = 10
+const tstampMillis = 1693401358754
+
+/* eslint-disable no-var */
+const run = bench([
+  function basicLog (cb) {
+    const pretty = prettyFactory({})
+    const input = `{"time":${tstampMillis},"pid":1,"hostname":"foo","msg":"benchmark","foo":"foo","bar":{"bar":"bar"}}\n`
+    for (var i = 0; i < max; i += 1) {
+      pretty(input)
+    }
+    setImmediate(cb)
+  },
+
+  function objectLog (cb) {
+    const pretty = prettyFactory({})
+    const input = {
+      time: tstampMillis,
+      pid: 1,
+      hostname: 'foo',
+      msg: 'benchmark',
+      foo: 'foo',
+      bar: { bar: 'bar' }
+    }
+    for (var i = 0; i < max; i += 1) {
+      pretty(input)
+    }
+    setImmediate(cb)
+  },
+
+  function coloredLog (cb) {
+    const pretty = prettyFactory({ colorize: true })
+    const input = `{"time":${tstampMillis},"pid":1,"hostname":"foo","msg":"benchmark","foo":"foo","bar":{"bar":"bar"}}\n`
+    for (var i = 0; i < max; i += 1) {
+      pretty(input)
+    }
+    setImmediate(cb)
+  },
+
+  function customPrettifiers (cb) {
+    const pretty = prettyFactory({
+      customPrettifiers: {
+        time (tstamp) {
+          return tstamp
+        },
+        pid () {
+          return ''
+        }
+      }
+    })
+    const input = `{"time":${tstampMillis},"pid":1,"hostname":"foo","msg":"benchmark","foo":"foo","bar":{"bar":"bar"}}\n`
+    for (var i = 0; i < max; i += 1) {
+      pretty(input)
+    }
+    setImmediate(cb)
+  },
+
+  function logWithErrorObject (cb) {
+    const pretty = prettyFactory({})
+    const err = Error('boom')
+    const input = `{"time":${tstampMillis},"pid":1,"hostname":"foo","msg":"benchmark","foo":"foo","bar":{"bar":"bar"},"err":{"message":"${err.message}","stack":"${err.stack}"}}\n`
+    for (var i = 0; i < max; i += 1) {
+      pretty(input)
+    }
+    setImmediate(cb)
+  },
+
+  function logRemappedMsgErrKeys (cb) {
+    const pretty = prettyFactory({
+      messageKey: 'message',
+      errorLikeObjectKeys: ['myError']
+    })
+    const err = Error('boom')
+    const input = `{"time":${tstampMillis},"pid":1,"hostname":"foo","message":"benchmark","foo":"foo","bar":{"bar":"bar"},"myError":{"message":"${err.message}","stack":"${err.stack}"}}\n`
+    for (var i = 0; i < max; i += 1) {
+      pretty(input)
+    }
+    setImmediate(cb)
+  },
+
+  function messageFormatString (cb) {
+    const pretty = prettyFactory({
+      messageFormat: '{levelLabel}{if pid} {pid} - {end}{msg}'
+    })
+    const input = `{"time":${tstampMillis},"pid":1,"hostname":"foo","msg":"benchmark","foo":"foo","bar":{"bar":"bar"}}\n`
+    for (var i = 0; i < max; i += 1) {
+      pretty(input)
+    }
+    setImmediate(cb)
+  }
+], 10000)
+
+run(run)

package/node_modules/pino-pretty/bin.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+const help = require('help-me')({
+  dir: path.join(__dirname, 'help'),
+  ext: '.txt'
+})
+const pump = require('pump')
+const sjp = require('secure-json-parse')
+const JoyCon = require('joycon')
+const { default: stripJsonComments } = require('strip-json-comments')
+
+const build = require('./')
+const CONSTANTS = require('./lib/constants')
+const { isObject } = require('./lib/utils')
+const minimist = require('minimist')
+
+const parseJSON = input => {
+  return sjp.parse(stripJsonComments(input), { protoAction: 'remove' })
+}
+
+const joycon = new JoyCon({
+  parseJSON,
+  files: [
+    'pino-pretty.config.cjs',
+    'pino-pretty.config.js',
+    '.pino-prettyrc',
+    '.pino-prettyrc.json'
+  ],
+  stopDir: path.dirname(process.cwd())
+})
+
+const cmd = minimist(process.argv.slice(2))
+
+if (cmd.h || cmd.help) {
+  help.toStdout()
+} else {
+  const DEFAULT_VALUE = '\0default'
+
+  let opts = minimist(process.argv, {
+    alias: {
+      colorize: 'c',
+      crlf: 'f',
+      errorProps: 'e',
+      levelFirst: 'l',
+      minimumLevel: 'L',
+      customLevels: 'x',
+      customColors: 'X',
+      useOnlyCustomProps: 'U',
+      errorLikeObjectKeys: 'k',
+      messageKey: 'm',
+      levelKey: CONSTANTS.LEVEL_KEY,
+      levelLabel: 'b',
+      messageFormat: 'o',
+      timestampKey: 'a',
+      translateTime: 't',
+      ignore: 'i',
+      include: 'I',
+      hideObject: 'H',
+      singleLine: 'S'
+    },
+    default: {
+      messageKey: DEFAULT_VALUE,
+      minimumLevel: DEFAULT_VALUE,
+      levelKey: DEFAULT_VALUE,
+      timestampKey: DEFAULT_VALUE
+    }
+  })
+
+  // Remove default values
+  opts = filter(opts, value => value !== DEFAULT_VALUE)
+  const config = loadConfig(opts.config)
+  // Override config with cli options
+  opts = Object.assign({}, config, opts)
+  // set defaults
+  opts.errorLikeObjectKeys = opts.errorLikeObjectKeys || 'err,error'
+  opts.errorProps = opts.errorProps || ''
+
+  const res = build(opts)
+  pump(process.stdin, res)
+
+  // https://github.com/pinojs/pino/pull/358
+  /* istanbul ignore next */
+  if (!process.stdin.isTTY && !fs.fstatSync(process.stdin.fd).isFile()) {
+    process.once('SIGINT', function noOp () {})
+  }
+
+  function loadConfig (configPath) {
+    const files = configPath ? [path.resolve(configPath)] : undefined
+    const result = joycon.loadSync(files)
+    if (result.path && !isObject(result.data)) {
+      configPath = configPath || path.basename(result.path)
+      throw new Error(`Invalid runtime configuration file: ${configPath}`)
+    }
+    if (configPath && !result.data) {
+      throw new Error(`Failed to load runtime configuration file: ${configPath}`)
+    }
+    return result.data
+  }
+
+  function filter (obj, cb) {
+    return Object.keys(obj).reduce((acc, key) => {
+      const value = obj[key]
+      if (cb(value, key)) {
+        acc[key] = value
+      }
+      return acc
+    }, {})
+  }
+}

package/node_modules/pino-pretty/docs/help.md

@@ -0,0 +1,24 @@
+<a id="Systemd"></a>
+## Systemd example
+
+If you run your Node.js process via [Systemd](https://www.freedesktop.org/wiki/Software/systemd/) and you examine your logs with [journalctl](https://www.freedesktop.org/software/systemd/man/journalctl.html) some data will be duplicated. You can use a combination of `journalctl` options and `pino-pretty` options to shape the output.
+
+For example viewing the prettified logs of a process named `monitor` with `journalctl -u monitor -f | pino-pretty`, might output something like this:
+
+```
+Apr 24 07:40:01 nanopi node[6080]: {"level":30,"time":1587706801902,"pid":6080,"hostname":"nanopi","msg":"TT
+21","v":1}
+```
+As you can see, the timestamp, hostname, and pid are duplicated.
+If you just want the bare prettified Pino logs you can strip out the duplicate items from the `journalctl` output with the `-o cat` option of `journalctl`: 
+```
+journalctl -u monitor -f -o cat | pino-pretty
+```
+the output now looks something like this:
+```
+[1587706801902] INFO  (6080 on nanopi): TT 21
+```
+Make the output even more human readable by using the pino-pretty options `-t` to format the timestamp and `-i pid, hostname` to filter out hostname and pid:
+```
+[2020-04-24 05:42:24.836 +0000] INFO : TT 21
+``` 

package/node_modules/pino-pretty/eslint.config.js

@@ -0,0 +1,5 @@
+'use strict'
+
+module.exports = require('neostandard')({
+  ts: true
+})

package/node_modules/pino-pretty/help/help.txt

@@ -0,0 +1,68 @@
+  Usage: pino-pretty [options] [command]
+  
+  Commands:
+    help     Display help
+    version  Display version
+  
+  Options:
+    -c, --colorize              Force adding color sequences to the output
+    -C, --config                specify a path to a json file containing the pino-pretty options
+    -f, --crlf                  Append CRLF instead of LF to formatted lines
+    -X, --customColors          Override default colors using names from https://www.npmjs.com/package/colorette (`-X err:red,info:blue`)
+    -x, --customLevels          Override default levels (`-x err:99,info:1`)
+    -k, --errorLikeObjectKeys   Define which keys contain error objects (`-k err,error`) (defaults to `err,error`)
+    -e, --errorProps            Comma separated list of properties on error objects to show (`*` for all properties) (defaults to ``)
+    -h, --help                  Output usage information
+    -H, --hideObject            Hide objects from output (but not error object)
+    -i, --ignore                Ignore one or several keys: (`-i time,hostname`)
+    -I, --include               The opposite of `--ignore`, only include one or several keys: (`-I level,time`)
+    -l, --levelFirst            Display the log level as the first output field
+    -L, --levelKey [value]      Detect the log level under the specified key (defaults to "level")
+    -b, --levelLabel [value]    Output the log level using the specified label (defaults to "levelLabel")
+    -o, --messageFormat         Format output of message
+    -m, --messageKey [value]    Highlight the message under the specified key (defaults to "msg")
+    -L, --minimumLevel          Hide messages below the specified log level
+    -S, --singleLine            Print all non-error objects on a single line
+    -a, --timestampKey [value]  Display the timestamp from the specified key (defaults to "time")
+    -t, --translateTime         Display epoch timestamps as UTC ISO format or according to an optional format string (default ISO 8601)
+    -U, --useOnlyCustomProps    Only use custom levels and colors (if provided); don't fallback to default levels and colors (-U false)
+    -v, --version               Output the version number
+  
+  Examples:
+    - To prettify logs, simply pipe a log file through
+    $ cat log | pino-pretty
+
+    - To highlight a string at a key other than 'msg'
+    $ cat log | pino-pretty -m fooMessage
+
+    - To detect the log level at a key other than 'level'
+    $ cat log | pino-pretty --levelKey fooLevel
+
+    - To output the log level label using a key other than 'levelLabel'
+    $ cat log | pino-pretty --levelLabel LVL -o "{LVL}"
+
+    - To display timestamp from a key other than 'time'
+    $ cat log | pino-pretty -a fooTimestamp
+
+    - To convert Epoch timestamps to ISO timestamps use the -t option
+    $ cat log | pino-pretty -t
+
+    - To convert Epoch timestamps to local timezone format use the -t option with "SYS:" prefixed format string
+    $ cat log | pino-pretty -t "SYS:yyyy-mm-dd HH:MM:ss"
+
+    - To flip level and time/date in standard output use the -l option
+    $ cat log | pino-pretty -l
+
+    - Only prints messages with a minimum log level of info
+    $ cat log | pino-pretty -L info
+
+    - Prettify logs but don't print pid and hostname
+    $ cat log | pino-pretty -i pid,hostname
+    
+    - Prettify logs but only print time and level
+    $ cat log | pino-pretty -I time,level
+
+    - Loads options from a config file
+    $ cat log | pino-pretty --config=/path/to/config.json
+
+  

package/node_modules/pino-pretty/index.d.ts

@@ -0,0 +1,227 @@
+// Project: https://github.com/pinojs/pino-pretty#readme
+// Definitions by: Adam Vigneaux <https://github.com/AdamVig>
+//                 tearwyx <https://github.com/tearwyx>
+
+/// <reference types="node" />
+
+import { Transform } from 'node:stream'
+import { OnUnknown } from 'pino-abstract-transport'
+// @ts-ignore fall back to any if pino is not available, i.e. when running pino tests
+import { DestinationStream, Level } from 'pino'
+import * as Colorette from 'colorette'
+
+declare function PinoPretty (options?: PinoPretty.PrettyOptions): PinoPretty.PrettyStream
+declare namespace PinoPretty {
+  export function colorizerFactory (
+    useColors?: boolean,
+    customColors?: [number, string][],
+    useOnlyCustomProps?: boolean,
+  ): {
+    (
+      level?: number | string,
+      opts?: {
+        customLevels?: { [level: number]: string };
+        customLevelNames?: { [name: string]: number };
+      },
+    ): string,
+    message: (input: string | number) => string,
+    greyMessage: (input: string | number) => string,
+  }
+
+  export function prettyFactory (options: PrettyOptions): (inputData: any) => string
+
+  export interface PrettyOptions {
+    /**
+     * Hide objects from output (but not error object).
+     * @default false
+     */
+    hideObject?: boolean;
+    /**
+     * Translate the epoch time value into a human readable date and time string. This flag also can set the format
+     * string to apply when translating the date to human readable format. For a list of available pattern letters
+     * see the {@link https://www.npmjs.com/package/dateformat|dateformat documentation}.
+     * - The default format is `yyyy-mm-dd HH:MM:ss.l o` in UTC.
+     * - Requires a `SYS:` prefix to translate time to the local system's timezone. Use the shortcut `SYS:standard`
+     *   to translate time to `yyyy-mm-dd HH:MM:ss.l o` in system timezone.
+     * @default false
+     */
+    translateTime?: boolean | string;
+    /**
+     * If set to true, it will print the name of the log level as the first field in the log line.
+     * @default false
+     */
+    levelFirst?: boolean;
+    /**
+     * Define the key that contains the level of the log.
+     * @default "level"
+     */
+    levelKey?: string;
+    /**
+     * Output the log level using the specified label.
+     * @default "levelLabel"
+     */
+    levelLabel?: string;
+    /**
+     * The key in the JSON object to use as the highlighted message.
+     * @default "msg"
+     *
+     * Not required when used with pino >= 8.21.0
+     */
+    messageKey?: string;
+    /**
+     * Print each log message on a single line (errors will still be multi-line).
+     * @default false
+     */
+    singleLine?: boolean;
+    /**
+     * The key in the JSON object to use for timestamp display.
+     * @default "time"
+     */
+    timestampKey?: string;
+    /**
+     * The minimum log level to include in the output.
+     * @default "trace"
+     */
+    minimumLevel?: Level;
+    /**
+     * Format output of message, e.g. {level} - {pid} will output message: INFO - 1123
+     * @default false
+     *
+     * @example
+     * ```typescript
+     * {
+     *   messageFormat: (log, messageKey) => {
+     *     const message = log[messageKey];
+     *     if (log.requestId) return `[${log.requestId}] ${message}`;
+     *     return message;
+     *   }
+     * }
+     * ```
+     */
+    messageFormat?: false | string | MessageFormatFunc;
+    /**
+     * If set to true, will add color information to the formatted output message.
+     * @default false
+     */
+    colorize?: boolean;
+    /**
+     * If set to false while `colorize` is `true`, will output JSON objects without color.
+     * @default true
+     */
+    colorizeObjects?: boolean;
+    /**
+     * Appends carriage return and line feed, instead of just a line feed, to the formatted log line.
+     * @default false
+     */
+    crlf?: boolean;
+    /**
+     * Define the log keys that are associated with error like objects.
+     * @default ["err", "error"]
+     *
+     * Not required to handle custom errorKey when used with pino >= 8.21.0
+     */
+    errorLikeObjectKeys?: string[];
+    /**
+     *  When formatting an error object, display this list of properties.
+     *  The list should be a comma separated list of properties.
+     * @default ""
+     */
+    errorProps?: string;
+    /**
+     * Ignore one or several keys.
+     * Will be overridden by the option include if include is presented.
+     * @example "time,hostname"
+     */
+    ignore?: string;
+    /**
+     * Include one or several keys.
+     * @example "time,level"
+     */
+    include?: string;
+    /**
+     * Makes messaging synchronous.
+     * @default false
+     */
+    sync?: boolean;
+    /**
+     * The file, file descriptor, or stream to write to.  Defaults to 1 (stdout).
+     * @default 1
+     */
+    destination?: string | number | DestinationStream | NodeJS.WritableStream;
+    /**
+     * Opens the file with the 'a' flag.
+     * @default true
+     */
+    append?: boolean;
+    /**
+     * Ensure directory for destination file exists.
+     * @default false
+     */
+    mkdir?: boolean;
+    /**
+     * Provides the ability to add a custom prettify function for specific log properties.
+     * `customPrettifiers` is an object, where keys are log properties that will be prettified
+     * and value is the prettify function itself.
+     * For example, if a log line contains a query property, you can specify a prettifier for it:
+     * @default {}
+     *
+     * @example
+     * ```typescript
+     * {
+     *   customPrettifiers: {
+     *     query: prettifyQuery
+     *   }
+     * }
+     * //...
+     * const prettifyQuery = value => {
+     *  // do some prettify magic
+     * }
+     * ```
+     */
+    customPrettifiers?: Record<string, Prettifier> &
+      {
+        level?: Prettifier
+      };
+    /**
+     * Change the level names and values to an user custom preset.
+     *
+     * Can be a CSV string in 'level_name:level_value' format or an object.
+     *
+     * @example ( CSV ) customLevels: 'info:10,some_level:40'
+     * @example ( Object ) customLevels: { info: 10, some_level: 40 }
+     *
+     * Not required when used with pino >= 8.21.0
+     */
+    customLevels?: string | object;
+    /**
+     * Change the level colors to an user custom preset.
+     *
+     * Can be a CSV string in 'level_name:color_value' format or an object.
+     * Also supports 'default' as level_name for fallback color.
+     *
+     * @example ( CSV ) customColors: 'info:white,some_level:red'
+     * @example ( Object ) customColors: { info: 'white', some_level: 'red' }
+     */
+    customColors?: string | object;
+    /**
+     * Only use custom levels and colors (if provided); else fallback to default levels and colors.
+     *
+     * @default true
+     */
+    useOnlyCustomProps?: boolean;
+  }
+
+  export function build (options?: PrettyOptions): PrettyStream
+
+  type PrettifierExtras = { colors: Colorette.Colorette, label: string, labelColorized: string }
+  export type Prettifier = (inputData: string | object, key: string, log: object, extras: PrettifierExtras) => string
+  export type MessageFormatFunc = (log: Record<string, unknown>, messageKey: string, levelLabel: string, extras: Pick<PrettifierExtras, 'colors'>) => string
+  export type PrettyStream = Transform & OnUnknown
+
+  // @ts-ignore
+  export const isColorSupported = Colorette.isColorSupported
+
+  export { PinoPretty }
+}
+
+export = PinoPretty