@wbce/projen-d9 0.0.27 → 0.1.0

package/node_modules/pino-pretty/index.js

@@ -0,0 +1,234 @@
+'use strict'
+
+const { isColorSupported } = require('colorette')
+const pump = require('pump')
+const { Transform } = require('node:stream')
+const abstractTransport = require('pino-abstract-transport')
+const colors = require('./lib/colors')
+const {
+  ERROR_LIKE_KEYS,
+  LEVEL_KEY,
+  LEVEL_LABEL,
+  MESSAGE_KEY,
+  TIMESTAMP_KEY
+} = require('./lib/constants')
+const {
+  buildSafeSonicBoom,
+  parseFactoryOptions
+} = require('./lib/utils')
+const pretty = require('./lib/pretty')
+
+/**
+ * @typedef {object} PinoPrettyOptions
+ * @property {boolean} [colorize] Indicates if colors should be used when
+ * prettifying. The default will be determined by the terminal capabilities at
+ * run time.
+ * @property {boolean} [colorizeObjects=true] Apply coloring to rendered objects
+ * when coloring is enabled.
+ * @property {boolean} [crlf=false] End lines with `\r\n` instead of `\n`.
+ * @property {string|null} [customColors=null] A comma separated list of colors
+ * to use for specific level labels, e.g. `err:red,info:blue`.
+ * @property {string|null} [customLevels=null] A comma separated list of user
+ * defined level names and numbers, e.g. `err:99,info:1`.
+ * @property {CustomPrettifiers} [customPrettifiers={}] A set of prettifier
+ * functions to apply to keys defined in this object.
+ * @property {K_ERROR_LIKE_KEYS} [errorLikeObjectKeys] A list of string property
+ * names to consider as error objects.
+ * @property {string} [errorProps=''] A comma separated list of properties on
+ * error objects to include in the output.
+ * @property {boolean} [hideObject=false] When `true`, data objects will be
+ * omitted from the output (except for error objects).
+ * @property {string} [ignore='hostname'] A comma separated list of log keys
+ * to omit when outputting the prettified log information.
+ * @property {undefined|string} [include=undefined] A comma separated list of
+ * log keys to include in the prettified log information. Only the keys in this
+ * list will be included in the output.
+ * @property {boolean} [levelFirst=false] When true, the log level will be the
+ * first field in the prettified output.
+ * @property {string} [levelKey='level'] The key name in the log data that
+ * contains the level value for the log.
+ * @property {string} [levelLabel='levelLabel'] Token name to use in
+ * `messageFormat` to represent the name of the logged level.
+ * @property {null|MessageFormatString|MessageFormatFunction} [messageFormat=null]
+ * When a string, defines how the prettified line should be formatted according
+ * to defined tokens. When a function, a synchronous function that returns a
+ * formatted string.
+ * @property {string} [messageKey='msg'] Defines the key in incoming logs that
+ * contains the message of the log, if present.
+ * @property {undefined|string|number} [minimumLevel=undefined] The minimum
+ * level for logs that should be processed. Any logs below this level will
+ * be omitted.
+ * @property {boolean} [singleLine=false] When `true` any objects, except error
+ * objects, in the log data will be printed as a single line instead as multiple
+ * lines.
+ * @property {string} [timestampKey='time'] Defines the key in incoming logs
+ * that contains the timestamp of the log, if present.
+ * @property {boolean|string} [translateTime=true] When true, will translate a
+ * JavaScript date integer into a human-readable string. If set to a string,
+ * it must be a format string.
+ * @property {boolean} [useOnlyCustomProps=true] When true, only custom levels
+ * and colors will be used if they have been provided.
+ */
+
+/**
+ * The default options that will be used when prettifying log lines.
+ *
+ * @type {PinoPrettyOptions}
+ */
+const defaultOptions = {
+  colorize: isColorSupported,
+  colorizeObjects: true,
+  crlf: false,
+  customColors: null,
+  customLevels: null,
+  customPrettifiers: {},
+  errorLikeObjectKeys: ERROR_LIKE_KEYS,
+  errorProps: '',
+  hideObject: false,
+  ignore: 'hostname',
+  include: undefined,
+  levelFirst: false,
+  levelKey: LEVEL_KEY,
+  levelLabel: LEVEL_LABEL,
+  messageFormat: null,
+  messageKey: MESSAGE_KEY,
+  minimumLevel: undefined,
+  singleLine: false,
+  timestampKey: TIMESTAMP_KEY,
+  translateTime: true,
+  useOnlyCustomProps: true
+}
+
+/**
+ * Normalizes a value to a boolean if it's the string "true" or "false".
+ * Otherwise returns the value unchanged.
+ *
+ * @param {any} value The value to normalize
+ * @returns {any} The normalized value
+ */
+function normalizeBoolean (value) {
+  if (value === 'true') return true
+  if (value === 'false') return false
+  return value
+}
+
+/**
+ * Normalizes boolean options by converting "true" and "false" strings to booleans.
+ *
+ * @param {PinoPrettyOptions} options The options to normalize
+ * @returns {PinoPrettyOptions} The normalized options
+ */
+function normalizeBooleanOptions (options) {
+  const normalized = { ...options }
+  const booleanOptions = [
+    'colorize',
+    'colorizeObjects',
+    'crlf',
+    'hideObject',
+    'levelFirst',
+    'singleLine',
+    'useOnlyCustomProps'
+  ]
+
+  for (const key of booleanOptions) {
+    if (key in normalized) {
+      normalized[key] = normalizeBoolean(normalized[key])
+    }
+  }
+
+  // translateTime can be boolean or string (format string)
+  // Only normalize if it's exactly "true" or "false"
+  if ('translateTime' in normalized && (normalized.translateTime === 'true' || normalized.translateTime === 'false')) {
+    normalized.translateTime = normalizeBoolean(normalized.translateTime)
+  }
+
+  return normalized
+}
+
+/**
+ * Processes the supplied options and returns a function that accepts log data
+ * and produces a prettified log string.
+ *
+ * @param {PinoPrettyOptions} options Configuration for the prettifier.
+ * @returns {LogPrettifierFunc}
+ */
+function prettyFactory (options) {
+  const mergedOptions = Object.assign({}, defaultOptions, options)
+  const normalizedOptions = normalizeBooleanOptions(mergedOptions)
+  const context = parseFactoryOptions(normalizedOptions)
+  return pretty.bind({ ...context, context })
+}
+
+/**
+ * @typedef {PinoPrettyOptions} BuildStreamOpts
+ * @property {object|number|string} [destination] A destination stream, file
+ * descriptor, or target path to a file.
+ * @property {boolean} [append]
+ * @property {boolean} [mkdir]
+ * @property {boolean} [sync=false]
+ */
+
+/**
+ * Constructs a {@link LogPrettifierFunc} and a stream to which the produced
+ * prettified log data will be written.
+ *
+ * @param {BuildStreamOpts} opts
+ * @returns {Transform | (Transform & OnUnknown)}
+ */
+function build (opts = {}) {
+  let pretty = prettyFactory(opts)
+  let destination
+  return abstractTransport(function (source) {
+    source.on('message', function pinoConfigListener (message) {
+      if (!message || message.code !== 'PINO_CONFIG') return
+      Object.assign(opts, {
+        messageKey: message.config.messageKey,
+        errorLikeObjectKeys: Array.from(new Set([...(opts.errorLikeObjectKeys || ERROR_LIKE_KEYS), message.config.errorKey])),
+        customLevels: message.config.levels.values
+      })
+      pretty = prettyFactory(opts)
+      source.off('message', pinoConfigListener)
+    })
+    const stream = new Transform({
+      objectMode: true,
+      autoDestroy: true,
+      transform (chunk, enc, cb) {
+        const line = pretty(chunk)
+        cb(null, line)
+      }
+    })
+
+    if (typeof opts.destination === 'object' && typeof opts.destination.write === 'function') {
+      destination = opts.destination
+    } else {
+      destination = buildSafeSonicBoom({
+        dest: opts.destination || 1,
+        append: opts.append,
+        mkdir: opts.mkdir,
+        sync: opts.sync // by default sonic will be async
+      })
+    }
+
+    source.on('unknown', function (line) {
+      destination.write(line + '\n')
+    })
+
+    pump(source, stream, destination)
+    return stream
+  }, {
+    parse: 'lines',
+    close (err, cb) {
+      destination.on('close', () => {
+        cb(err)
+      })
+    }
+  })
+}
+
+module.exports = build
+module.exports.build = build
+module.exports.PinoPretty = build
+module.exports.prettyFactory = prettyFactory
+module.exports.colorizerFactory = colors
+module.exports.isColorSupported = isColorSupported
+module.exports.default = build

package/node_modules/pino-pretty/lib/colors.js

@@ -0,0 +1,134 @@
+'use strict'
+
+const nocolor = input => input
+const plain = {
+  default: nocolor,
+  60: nocolor,
+  50: nocolor,
+  40: nocolor,
+  30: nocolor,
+  20: nocolor,
+  10: nocolor,
+  message: nocolor,
+  greyMessage: nocolor,
+  property: nocolor
+}
+
+const { createColors } = require('colorette')
+const getLevelLabelData = require('./utils/get-level-label-data')
+const availableColors = createColors({ useColor: true })
+const { white, bgRed, red, yellow, green, blue, gray, cyan, magenta } = availableColors
+
+const colored = {
+  default: white,
+  60: bgRed,
+  50: red,
+  40: yellow,
+  30: green,
+  20: blue,
+  10: gray,
+  message: cyan,
+  greyMessage: gray,
+  property: magenta
+}
+
+function resolveCustomColoredColorizer (customColors) {
+  return customColors.reduce(
+    function (agg, [level, color]) {
+      agg[level] = typeof availableColors[color] === 'function' ? availableColors[color] : white
+
+      return agg
+    },
+    { default: white, message: cyan, greyMessage: gray, property: magenta }
+  )
+}
+
+function colorizeLevel (useOnlyCustomProps) {
+  return function (level, colorizer, { customLevels, customLevelNames } = {}) {
+    const [levelStr, levelNum] = getLevelLabelData(useOnlyCustomProps, customLevels, customLevelNames)(level)
+
+    return Object.prototype.hasOwnProperty.call(colorizer, levelNum) ? colorizer[levelNum](levelStr) : colorizer.default(levelStr)
+  }
+}
+
+function plainColorizer (useOnlyCustomProps) {
+  const newPlainColorizer = colorizeLevel(useOnlyCustomProps)
+  const customColoredColorizer = function (level, opts) {
+    return newPlainColorizer(level, plain, opts)
+  }
+  customColoredColorizer.message = plain.message
+  customColoredColorizer.greyMessage = plain.greyMessage
+  customColoredColorizer.property = plain.property
+  customColoredColorizer.colors = createColors({ useColor: false })
+  return customColoredColorizer
+}
+
+function coloredColorizer (useOnlyCustomProps) {
+  const newColoredColorizer = colorizeLevel(useOnlyCustomProps)
+  const customColoredColorizer = function (level, opts) {
+    return newColoredColorizer(level, colored, opts)
+  }
+  customColoredColorizer.message = colored.message
+  customColoredColorizer.property = colored.property
+  customColoredColorizer.greyMessage = colored.greyMessage
+  customColoredColorizer.colors = availableColors
+  return customColoredColorizer
+}
+
+function customColoredColorizerFactory (customColors, useOnlyCustomProps) {
+  const onlyCustomColored = resolveCustomColoredColorizer(customColors)
+  const customColored = useOnlyCustomProps ? onlyCustomColored : Object.assign({}, colored, onlyCustomColored)
+  const colorizeLevelCustom = colorizeLevel(useOnlyCustomProps)
+
+  const customColoredColorizer = function (level, opts) {
+    return colorizeLevelCustom(level, customColored, opts)
+  }
+  customColoredColorizer.colors = availableColors
+  customColoredColorizer.message = customColoredColorizer.message || customColored.message
+  customColoredColorizer.property = customColoredColorizer.property || customColored.property
+  customColoredColorizer.greyMessage = customColoredColorizer.greyMessage || customColored.greyMessage
+
+  return customColoredColorizer
+}
+
+/**
+ * Applies colorization, if possible, to a string representing the passed in
+ * `level`. For example, the default colorizer will return a "green" colored
+ * string for the "info" level.
+ *
+ * @typedef {function} ColorizerFunc
+ * @param {string|number} level In either case, the input will map to a color
+ * for the specified level or to the color for `USERLVL` if the level is not
+ * recognized.
+ * @property {function} message Accepts one string parameter that will be
+ * colorized to a predefined color.
+ * @property {Colorette.Colorette} colors Available color functions based on `useColor` (or `colorize`) context
+ */
+
+/**
+ * Factory function get a function to colorized levels. The returned function
+ * also includes a `.message(str)` method to colorize strings.
+ *
+ * @param {boolean} [useColors=false] When `true` a function that applies standard
+ * terminal colors is returned.
+ * @param {array[]} [customColors] Tuple where first item of each array is the
+ * level index and the second item is the color
+ * @param {boolean} [useOnlyCustomProps] When `true`, only use the provided
+ * custom colors provided and not fallback to default
+ *
+ * @returns {ColorizerFunc} `function (level) {}` has a `.message(str)` method to
+ * apply colorization to a string. The core function accepts either an integer
+ * `level` or a `string` level. The integer level will map to a known level
+ * string or to `USERLVL` if not known.  The string `level` will map to the same
+ * colors as the integer `level` and will also default to `USERLVL` if the given
+ * string is not a recognized level name.
+ */
+module.exports = function getColorizer (useColors = false, customColors, useOnlyCustomProps) {
+  if (useColors && customColors !== undefined) {
+    return customColoredColorizerFactory(customColors, useOnlyCustomProps)
+  } else if (useColors) {
+    return coloredColorizer(useOnlyCustomProps)
+  }
+
+  return plainColorizer(useOnlyCustomProps)
+}

package/node_modules/pino-pretty/lib/colors.test.js

@@ -0,0 +1,132 @@
+'use strict'
+
+const { test } = require('node:test')
+const getColorizer = require('./colors')
+
+const testDefaultColorizer = getColorizer => t => {
+  const colorizer = getColorizer()
+  let colorized = colorizer(10)
+  t.assert.strictEqual(colorized, 'TRACE')
+
+  colorized = colorizer(20)
+  t.assert.strictEqual(colorized, 'DEBUG')
+
+  colorized = colorizer(30)
+  t.assert.strictEqual(colorized, 'INFO')
+
+  colorized = colorizer(40)
+  t.assert.strictEqual(colorized, 'WARN')
+
+  colorized = colorizer(50)
+  t.assert.strictEqual(colorized, 'ERROR')
+
+  colorized = colorizer(60)
+  t.assert.strictEqual(colorized, 'FATAL')
+
+  colorized = colorizer(900)
+  t.assert.strictEqual(colorized, 'USERLVL')
+
+  colorized = colorizer('info')
+  t.assert.strictEqual(colorized, 'INFO')
+
+  colorized = colorizer('use-default')
+  t.assert.strictEqual(colorized, 'USERLVL')
+
+  colorized = colorizer.message('foo')
+  t.assert.strictEqual(colorized, 'foo')
+
+  colorized = colorizer.greyMessage('foo')
+  t.assert.strictEqual(colorized, 'foo')
+}
+
+const testColoringColorizer = getColorizer => t => {
+  const colorizer = getColorizer(true)
+  let colorized = colorizer(10)
+  t.assert.strictEqual(colorized, '\u001B[90mTRACE\u001B[39m')
+
+  colorized = colorizer(20)
+  t.assert.strictEqual(colorized, '\u001B[34mDEBUG\u001B[39m')
+
+  colorized = colorizer(30)
+  t.assert.strictEqual(colorized, '\u001B[32mINFO\u001B[39m')
+
+  colorized = colorizer(40)
+  t.assert.strictEqual(colorized, '\u001B[33mWARN\u001B[39m')
+
+  colorized = colorizer(50)
+  t.assert.strictEqual(colorized, '\u001B[31mERROR\u001B[39m')
+
+  colorized = colorizer(60)
+  t.assert.strictEqual(colorized, '\u001B[41mFATAL\u001B[49m')
+
+  colorized = colorizer(900)
+  t.assert.strictEqual(colorized, '\u001B[37mUSERLVL\u001B[39m')
+
+  colorized = colorizer('info')
+  t.assert.strictEqual(colorized, '\u001B[32mINFO\u001B[39m')
+
+  colorized = colorizer('use-default')
+  t.assert.strictEqual(colorized, '\u001B[37mUSERLVL\u001B[39m')
+
+  colorized = colorizer.message('foo')
+  t.assert.strictEqual(colorized, '\u001B[36mfoo\u001B[39m')
+
+  colorized = colorizer.greyMessage('foo')
+  t.assert.strictEqual(colorized, '\u001B[90mfoo\u001B[39m')
+}
+
+const testCustomColoringColorizer = getColorizer => t => {
+  const customLevels = {
+    0: 'INFO',
+    1: 'ERR',
+    default: 'USERLVL'
+  }
+  const customLevelNames = {
+    info: 0,
+    err: 1
+  }
+  const customColors = [
+    [0, 'not-a-color'],
+    [1, 'red']
+  ]
+  const opts = {
+    customLevels,
+    customLevelNames
+  }
+
+  const colorizer = getColorizer(true, customColors)
+  const colorizerWithCustomPropUse = getColorizer(true, customColors, true)
+  let colorized = colorizer(1, opts)
+  t.assert.strictEqual(colorized, '\u001B[31mERR\u001B[39m')
+
+  colorized = colorizer(0, opts)
+  t.assert.strictEqual(colorized, '\u001B[37mINFO\u001B[39m')
+
+  colorized = colorizer(900)
+  t.assert.strictEqual(colorized, '\u001B[37mUSERLVL\u001B[39m')
+
+  colorized = colorizer('err', opts)
+  t.assert.strictEqual(colorized, '\u001B[31mERR\u001B[39m')
+
+  colorized = colorizer('info', opts)
+  t.assert.strictEqual(colorized, '\u001B[37mINFO\u001B[39m')
+
+  colorized = colorizer('use-default')
+  t.assert.strictEqual(colorized, '\u001B[37mUSERLVL\u001B[39m')
+
+  colorized = colorizer(40, opts)
+  t.assert.strictEqual(colorized, '\u001B[33mWARN\u001B[39m')
+
+  colorized = colorizerWithCustomPropUse(50, opts)
+  t.assert.strictEqual(colorized, '\u001B[37mUSERLVL\u001B[39m')
+}
+
+test('returns default colorizer - private export', testDefaultColorizer(getColorizer))
+test('returns colorizing colorizer - private export', testColoringColorizer(getColorizer))
+test('returns custom colorizing colorizer - private export', testCustomColoringColorizer(getColorizer))
+
+test('custom props defaults to standard levels', t => {
+  const colorizer = getColorizer(true, [], true)
+  const colorized = colorizer('info')
+  t.assert.strictEqual(colorized, '\u001B[37mINFO\u001B[39m')
+})

package/node_modules/pino-pretty/lib/constants.js

@@ -0,0 +1,55 @@
+'use strict'
+
+/**
+ * A set of property names that indicate the value represents an error object.
+ *
+ * @typedef {string[]} K_ERROR_LIKE_KEYS
+ */
+
+module.exports = {
+  DATE_FORMAT: 'yyyy-mm-dd HH:MM:ss.l o',
+  DATE_FORMAT_SIMPLE: 'HH:MM:ss.l',
+
+  /**
+   * @type {K_ERROR_LIKE_KEYS}
+   */
+  ERROR_LIKE_KEYS: ['err', 'error'],
+
+  MESSAGE_KEY: 'msg',
+
+  LEVEL_KEY: 'level',
+
+  LEVEL_LABEL: 'levelLabel',
+
+  TIMESTAMP_KEY: 'time',
+
+  LEVELS: {
+    default: 'USERLVL',
+    60: 'FATAL',
+    50: 'ERROR',
+    40: 'WARN',
+    30: 'INFO',
+    20: 'DEBUG',
+    10: 'TRACE'
+  },
+
+  LEVEL_NAMES: {
+    fatal: 60,
+    error: 50,
+    warn: 40,
+    info: 30,
+    debug: 20,
+    trace: 10
+  },
+
+  // Object keys that probably came from a logger like Pino or Bunyan.
+  LOGGER_KEYS: [
+    'pid',
+    'hostname',
+    'name',
+    'level',
+    'time',
+    'timestamp',
+    'caller'
+  ]
+}