@wbce/projen-d9 0.0.28 → 0.1.1

package/node_modules/pino-pretty/lib/utils/index.js

@@ -0,0 +1,108 @@
+'use strict'
+
+module.exports = {
+  buildSafeSonicBoom: require('./build-safe-sonic-boom.js'),
+  createDate: require('./create-date.js'),
+  deleteLogProperty: require('./delete-log-property.js'),
+  filterLog: require('./filter-log.js'),
+  formatTime: require('./format-time.js'),
+  getPropertyValue: require('./get-property-value.js'),
+  handleCustomLevelsNamesOpts: require('./handle-custom-levels-names-opts.js'),
+  handleCustomLevelsOpts: require('./handle-custom-levels-opts.js'),
+  interpretConditionals: require('./interpret-conditionals.js'),
+  isObject: require('./is-object.js'),
+  isValidDate: require('./is-valid-date.js'),
+  joinLinesWithIndentation: require('./join-lines-with-indentation.js'),
+  noop: require('./noop.js'),
+  parseFactoryOptions: require('./parse-factory-options.js'),
+  prettifyErrorLog: require('./prettify-error-log.js'),
+  prettifyError: require('./prettify-error.js'),
+  prettifyLevel: require('./prettify-level.js'),
+  prettifyMessage: require('./prettify-message.js'),
+  prettifyMetadata: require('./prettify-metadata.js'),
+  prettifyObject: require('./prettify-object.js'),
+  prettifyTime: require('./prettify-time.js'),
+  splitPropertyKey: require('./split-property-key.js'),
+  stripUnsafeControlChars: require('./strip-unsafe-control-chars.js'),
+  getLevelLabelData: require('./get-level-label-data')
+}
+
+// The remainder of this file consists of jsdoc blocks that are difficult to
+// determine a more appropriate "home" for. As an example, the blocks associated
+// with custom prettifiers could live in either the `prettify-level`,
+// `prettify-metadata`, or `prettify-time` files since they are the primary
+// files where such code is used. But we want a central place to define common
+// doc blocks, so we are picking this file as the answer.
+
+/**
+ * A hash of log property names mapped to prettifier functions. When the
+ * incoming log data is being processed for prettification, any key on the log
+ * that matches a key in a custom prettifiers hash will be prettified using
+ * that matching custom prettifier. The value passed to the custom prettifier
+ * will the value associated with the corresponding log key.
+ *
+ * The hash may contain any arbitrary keys for arbitrary log properties, but it
+ * may also contain a set of predefined key names that map to well-known log
+ * properties. These keys are:
+ *
+ * + `time` (for the timestamp field)
+ * + `level` (for the level label field; value may be a level number instead
+ * of a level label)
+ * + `hostname`
+ * + `pid`
+ * + `name`
+ * + `caller`
+ *
+ * @typedef {Object.<string, CustomPrettifierFunc>} CustomPrettifiers
+ */
+
+/**
+ * A synchronous function to be used for prettifying a log property. It must
+ * return a string.
+ *
+ * @typedef {function} CustomPrettifierFunc
+ * @param {any} value The value to be prettified for the key associated with
+ * the prettifier.
+ * @returns {string}
+ */
+
+/**
+ * A tokenized string that indicates how the prettified log line should be
+ * formatted. Tokens are either log properties enclosed in curly braces, e.g.
+ * `{levelLabel}`, `{pid}`, or `{req.url}`, or conditional directives in curly
+ * braces. The only conditional directives supported are `if` and `end`, e.g.
+ * `{if pid}{pid}{end}`; every `if` must have a matching `end`. Nested
+ * conditions are not supported.
+ *
+ * @typedef {string} MessageFormatString
+ *
+ * @example
+ * `{levelLabel} - {if pid}{pid} - {end}url:{req.url}`
+ */
+
+/**
+ * @typedef {object} PrettifyMessageExtras
+ * @property {object} colors Available color functions based on `useColor` (or `colorize`) context
+ * the options.
+ */
+
+/**
+ * A function that accepts a log object, name of the message key, and name of
+ * the level label key and returns a formatted log line.
+ *
+ * Note: this function must be synchronous.
+ *
+ * @typedef {function} MessageFormatFunction
+ * @param {object} log The log object to be processed.
+ * @param {string} messageKey The name of the key in the `log` object that
+ * contains the log message.
+ * @param {string} levelLabel The name of the key in the `log` object that
+ * contains the log level name.
+ * @param {PrettifyMessageExtras} extras Additional data available for message context
+ * @returns {string}
+ *
+ * @example
+ * function (log, messageKey, levelLabel) {
+ *   return `${log[levelLabel]} - ${log[messageKey]}`
+ * }
+ */

package/node_modules/pino-pretty/lib/utils/index.test.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const { test } = require('node:test')
+const index = require('./index.js')
+const { readdirSync } = require('node:fs')
+const { basename } = require('node:path')
+
+test(
+  'index exports exactly all non-test files excluding itself',
+  t => {
+    // Read all files in the `util` directory
+    const files = readdirSync(__dirname)
+
+    for (const file of files) {
+      const kebabName = basename(file, '.js')
+      const snakeName = kebabName.split('-').map((part, idx) => {
+        if (idx === 0) return part
+        return part[0].toUpperCase() + part.slice(1)
+      }).join('')
+
+      if (file.endsWith('.test.js') === false && file !== 'index.js') {
+        // We expect all files to be exported except…
+        t.assert.ok(index[snakeName], `exports ${snakeName}`)
+      } else {
+        // …test files and the index file itself – those must not be exported
+        t.assert.ok(!index[snakeName], `does not export ${snakeName}`)
+      }
+
+      // Remove the exported file from the index object
+      delete index[snakeName]
+    }
+
+    // Now the index is expected to be empty, as nothing else should be
+    // exported from it
+    t.assert.deepStrictEqual(index, {}, 'does not export anything else')
+  }
+)

package/node_modules/pino-pretty/lib/utils/interpret-conditionals.js

@@ -0,0 +1,41 @@
+'use strict'
+
+module.exports = interpretConditionals
+
+const getPropertyValue = require('./get-property-value')
+
+/**
+ * Translates all conditional blocks from within the messageFormat. Translates
+ * any matching {if key}{key}{end} statements and returns everything between
+ * if and else blocks if the key provided was found in log.
+ *
+ * @param {MessageFormatString|MessageFormatFunction} messageFormat A format
+ * string or function that defines how the logged message should be
+ * conditionally formatted.
+ * @param {object} log The log object to be modified.
+ *
+ * @returns {string} The parsed messageFormat.
+ */
+function interpretConditionals (messageFormat, log) {
+  messageFormat = messageFormat.replace(/{if (.*?)}([\s\S]*?){end}/g, replacer)
+
+  // Remove non-terminated if blocks
+  messageFormat = messageFormat.replace(/{if (.*?)}/g, '')
+  // Remove floating end blocks
+  messageFormat = messageFormat.replace(/{end}/g, '')
+
+  // Collapse horizontal whitespace (spaces/tabs) without removing newlines
+  messageFormat = messageFormat.replace(/[^\S\r\n]+/g, ' ')
+  // Remove empty lines left over from removed conditional blocks
+  messageFormat = messageFormat.replace(/\n[^\S\r\n]*\n/g, '\n')
+  return messageFormat.trim()
+
+  function replacer (_, key, value) {
+    const propertyValue = getPropertyValue(log, key)
+    if (propertyValue && value.includes(key)) {
+      return value.replace(new RegExp('{' + key + '}', 'g'), propertyValue)
+    } else {
+      return ''
+    }
+  }
+}

package/node_modules/pino-pretty/lib/utils/interpret-conditionals.test.js

@@ -0,0 +1,84 @@
+'use strict'
+
+const { test } = require('node:test')
+const { createCopier } = require('fast-copy')
+const fastCopy = createCopier({})
+const interpretConditionals = require('./interpret-conditionals')
+
+const logData = {
+  level: 30,
+  data1: {
+    data2: 'bar'
+  },
+  msg: 'foo'
+}
+
+test('interpretConditionals translates if / else statement to found property value', t => {
+  const log = fastCopy(logData)
+  t.assert.strictEqual(interpretConditionals('{level} - {if data1.data2}{data1.data2}{end}', log), '{level} - bar')
+})
+
+test('interpretConditionals translates if / else statement to found property value and leave unmatched property key untouched', t => {
+  const log = fastCopy(logData)
+  t.assert.strictEqual(interpretConditionals('{level} - {if data1.data2}{data1.data2} ({msg}){end}', log), '{level} - bar ({msg})')
+})
+
+test('interpretConditionals removes non-terminated if statements', t => {
+  const log = fastCopy(logData)
+  t.assert.strictEqual(interpretConditionals('{level} - {if data1.data2}{data1.data2}', log), '{level} - {data1.data2}')
+})
+
+test('interpretConditionals removes floating end statements', t => {
+  const log = fastCopy(logData)
+  t.assert.strictEqual(interpretConditionals('{level} - {data1.data2}{end}', log), '{level} - {data1.data2}')
+})
+
+test('interpretConditionals removes floating end statements within translated if / end statements', t => {
+  const log = fastCopy(logData)
+  t.assert.strictEqual(interpretConditionals('{level} - {if msg}({msg}){end}{end}', log), '{level} - (foo)')
+})
+
+test('interpretConditionals removes if / end blocks if existent condition key does not match existent property key', t => {
+  const log = fastCopy(logData)
+  t.assert.strictEqual(interpretConditionals('{level}{if msg}{data1.data2}{end}', log), '{level}')
+})
+
+test('interpretConditionals removes if / end blocks if non-existent condition key does not match existent property key', t => {
+  const log = fastCopy(logData)
+  t.assert.strictEqual(interpretConditionals('{level}{if foo}{msg}{end}', log), '{level}')
+})
+
+test('interpretConditionals removes if / end blocks if existent condition key does not match non-existent property key', t => {
+  const log = fastCopy(logData)
+  t.assert.strictEqual(interpretConditionals('{level}{if msg}{foo}{end}', log), '{level}')
+})
+
+test('interpretConditionals removes if / end blocks if non-existent condition key does not match non-existent property key', t => {
+  const log = fastCopy(logData)
+  t.assert.strictEqual(interpretConditionals('{level}{if foo}{bar}{end}', log), '{level}')
+})
+
+test('interpretConditionals removes if / end blocks if nested condition key does not match property key', t => {
+  const log = fastCopy(logData)
+  t.assert.strictEqual(interpretConditionals('{level}{if data1.msg}{data1.data2}{end}', log), '{level}')
+})
+
+test('interpretConditionals removes nested if / end statement blocks', t => {
+  const log = fastCopy(logData)
+  t.assert.strictEqual(interpretConditionals('{if msg}{if data1.data2}{msg}{data1.data2}{end}{end}', log), 'foo{data1.data2}')
+})
+
+test('interpretConditionals preserves newlines in messageFormat', t => {
+  const log = fastCopy(logData)
+  t.assert.strictEqual(interpretConditionals('{msg}\n{level}', log), '{msg}\n{level}')
+})
+
+test('interpretConditionals preserves newlines with conditionals', t => {
+  const log = fastCopy(logData)
+  t.assert.strictEqual(interpretConditionals('{msg}{if data1.data2}\n{data1.data2}{end}', log), '{msg}\nbar')
+})
+
+test('interpretConditionals removes empty lines from removed conditionals', t => {
+  const log = fastCopy(logData)
+  t.assert.strictEqual(interpretConditionals('{msg}\n{if foo}{foo}{end}\n{level}', log), '{msg}\n{level}')
+})

package/node_modules/pino-pretty/lib/utils/is-object.js

@@ -0,0 +1,7 @@
+'use strict'
+
+module.exports = isObject
+
+function isObject (input) {
+  return Object.prototype.toString.apply(input) === '[object Object]'
+}

package/node_modules/pino-pretty/lib/utils/is-object.test.js

@@ -0,0 +1,10 @@
+'use strict'
+
+const { test } = require('node:test')
+const isObject = require('./is-object')
+
+test('returns correct answer', t => {
+  t.assert.strictEqual(isObject({}), true)
+  t.assert.strictEqual(isObject([]), false)
+  t.assert.strictEqual(isObject(42), false)
+})

package/node_modules/pino-pretty/lib/utils/is-valid-date.js

@@ -0,0 +1,14 @@
+'use strict'
+
+module.exports = isValidDate
+
+/**
+ * Checks if the argument is a JS Date and not 'Invalid Date'.
+ *
+ * @param {Date} date The date to check.
+ *
+ * @returns {boolean} true if the argument is a JS Date and not 'Invalid Date'.
+ */
+function isValidDate (date) {
+  return date instanceof Date && !Number.isNaN(date.getTime())
+}

package/node_modules/pino-pretty/lib/utils/is-valid-date.test.js

@@ -0,0 +1,16 @@
+'use strict'
+
+process.env.TZ = 'UTC'
+
+const { test } = require('node:test')
+const isValidDate = require('./is-valid-date')
+
+test('returns true for valid dates', t => {
+  t.assert.strictEqual(isValidDate(new Date()), true)
+})
+
+test('returns false for non-dates and invalid dates', t => {
+  t.plan(2)
+  t.assert.strictEqual(isValidDate('20210621'), false)
+  t.assert.strictEqual(isValidDate(new Date('2021-41-99')), false)
+})

package/node_modules/pino-pretty/lib/utils/join-lines-with-indentation.js

@@ -0,0 +1,29 @@
+'use strict'
+
+module.exports = joinLinesWithIndentation
+
+/**
+ * @typedef {object} JoinLinesWithIndentationParams
+ * @property {string} input The string to split and reformat.
+ * @property {string} [ident] The indentation string. Default: `    ` (4 spaces).
+ * @property {string} [eol] The end of line sequence to use when rejoining
+ * the lines. Default: `'\n'`.
+ */
+
+/**
+ * Given a string with line separators, either `\r\n` or `\n`, add indentation
+ * to all lines subsequent to the first line and rejoin the lines using an
+ * end of line sequence.
+ *
+ * @param {JoinLinesWithIndentationParams} input
+ *
+ * @returns {string} A string with lines subsequent to the first indented
+ * with the given indentation sequence.
+ */
+function joinLinesWithIndentation ({ input, ident = '    ', eol = '\n' }) {
+  const lines = input.split(/\r?\n/)
+  for (let i = 1; i < lines.length; i += 1) {
+    lines[i] = ident + lines[i]
+  }
+  return lines.join(eol)
+}

package/node_modules/pino-pretty/lib/utils/join-lines-with-indentation.test.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const { test } = require('node:test')
+const joinLinesWithIndentation = require('./join-lines-with-indentation')
+
+test('joinLinesWithIndentation adds indentation to beginning of subsequent lines', t => {
+  const input = 'foo\nbar\nbaz'
+  const result = joinLinesWithIndentation({ input })
+  t.assert.strictEqual(result, 'foo\n    bar\n    baz')
+})
+
+test('joinLinesWithIndentation accepts custom indentation, line breaks, and eol', t => {
+  const input = 'foo\nbar\r\nbaz'
+  const result = joinLinesWithIndentation({ input, ident: '  ', eol: '^' })
+  t.assert.strictEqual(result, 'foo^  bar^  baz')
+})

package/node_modules/pino-pretty/lib/utils/noop.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = function noop () {}

package/node_modules/pino-pretty/lib/utils/noop.test.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const { test } = require('node:test')
+const noop = require('./noop')
+
+test('is a function', t => {
+  t.assert.strictEqual(typeof noop, 'function')
+})
+
+test('does nothing', t => {
+  t.assert.strictEqual(noop('stuff'), undefined)
+})

package/node_modules/pino-pretty/lib/utils/parse-factory-options.js

@@ -0,0 +1,171 @@
+'use strict'
+
+module.exports = parseFactoryOptions
+
+const {
+  LEVEL_NAMES
+} = require('../constants')
+const colors = require('../colors')
+const handleCustomLevelsOpts = require('./handle-custom-levels-opts')
+const handleCustomLevelsNamesOpts = require('./handle-custom-levels-names-opts')
+const handleLevelLabelData = require('./get-level-label-data')
+
+/**
+ * A `PrettyContext` is an object to be used by the various functions that
+ * process log data. It is derived from the provided {@link PinoPrettyOptions}.
+ * It may be used as a `this` context.
+ *
+ * @typedef {object} PrettyContext
+ * @property {string} EOL The escape sequence chosen as the line terminator.
+ * @property {string} IDENT The string to use as the indentation sequence.
+ * @property {ColorizerFunc} colorizer A configured colorizer function.
+ * @property {Array[Array<number, string>]} customColors A set of custom color
+ * names associated with level numbers.
+ * @property {object} customLevelNames A hash of level numbers to level names,
+ * e.g. `{ 30: "info" }`.
+ * @property {object} customLevels A hash of level names to level numbers,
+ * e.g. `{ info: 30 }`.
+ * @property {CustomPrettifiers} customPrettifiers A hash of custom prettifier
+ * functions.
+ * @property {object} customProperties Comprised of `customLevels` and
+ * `customLevelNames` if such options are provided.
+ * @property {string[]} errorLikeObjectKeys The key names in the log data that
+ * should be considered as holding error objects.
+ * @property {string[]} errorProps A list of error object keys that should be
+ * included in the output.
+ * @property {function} getLevelLabelData Pass a numeric level to return [levelLabelString,levelNum]
+ * @property {boolean} hideObject Indicates the prettifier should omit objects
+ * in the output.
+ * @property {string[]} ignoreKeys Set of log data keys to omit.
+ * @property {string[]} includeKeys Opposite of `ignoreKeys`.
+ * @property {boolean} levelFirst Indicates the level should be printed first.
+ * @property {string} levelKey Name of the key in the log data that contains
+ * the message.
+ * @property {string} levelLabel Format token to represent the position of the
+ * level name in the output string.
+ * @property {MessageFormatString|MessageFormatFunction} messageFormat
+ * @property {string} messageKey Name of the key in the log data that contains
+ * the message.
+ * @property {string|number} minimumLevel The minimum log level to process
+ * and output.
+ * @property {ColorizerFunc} objectColorizer
+ * @property {boolean} singleLine Indicates objects should be printed on a
+ * single output line.
+ * @property {string} timestampKey The name of the key in the log data that
+ * contains the log timestamp.
+ * @property {boolean} translateTime Indicates if timestamps should be
+ * translated to a human-readable string.
+ * @property {boolean} useOnlyCustomProps
+ */
+
+/**
+ * @param {PinoPrettyOptions} options The user supplied object of options.
+ *
+ * @returns {PrettyContext}
+ */
+function parseFactoryOptions (options) {
+  const EOL = options.crlf ? '\r\n' : '\n'
+  const IDENT = '    '
+  const {
+    customPrettifiers,
+    errorLikeObjectKeys,
+    hideObject,
+    levelFirst,
+    levelKey,
+    levelLabel,
+    messageFormat,
+    messageKey,
+    minimumLevel,
+    singleLine,
+    timestampKey,
+    translateTime
+  } = options
+  const errorProps = options.errorProps.split(',')
+  const useOnlyCustomProps = options.useOnlyCustomProps
+  const customLevels = handleCustomLevelsOpts(options.customLevels)
+  const customLevelNames = handleCustomLevelsNamesOpts(options.customLevels)
+  const getLevelLabelData = handleLevelLabelData(useOnlyCustomProps, customLevels, customLevelNames)
+
+  let customColors
+  if (options.customColors) {
+    if (typeof options.customColors === 'string') {
+      customColors = options.customColors.split(',').reduce((agg, value) => {
+        const [level, color] = value.split(':')
+        const condition = useOnlyCustomProps
+          ? options.customLevels
+          : customLevelNames[level] !== undefined
+        const levelNum = condition
+          ? customLevelNames[level]
+          : LEVEL_NAMES[level]
+        const colorIdx = levelNum !== undefined
+          ? levelNum
+          : level
+        agg.push([colorIdx, color])
+        return agg
+      }, [])
+    } else if (typeof options.customColors === 'object') {
+      customColors = Object.keys(options.customColors).reduce((agg, value) => {
+        const [level, color] = [value, options.customColors[value]]
+        const condition = useOnlyCustomProps
+          ? options.customLevels
+          : customLevelNames[level] !== undefined
+        const levelNum = condition
+          ? customLevelNames[level]
+          : LEVEL_NAMES[level]
+        const colorIdx = levelNum !== undefined
+          ? levelNum
+          : level
+        agg.push([colorIdx, color])
+        return agg
+      }, [])
+    } else {
+      throw new Error('options.customColors must be of type string or object.')
+    }
+  }
+
+  const customProperties = { customLevels, customLevelNames }
+  if (useOnlyCustomProps === true && !options.customLevels) {
+    customProperties.customLevels = undefined
+    customProperties.customLevelNames = undefined
+  }
+
+  const includeKeys = options.include !== undefined
+    ? new Set(options.include.split(','))
+    : undefined
+  const ignoreKeys = (!includeKeys && options.ignore)
+    ? new Set(options.ignore.split(','))
+    : undefined
+
+  const colorizer = colors(options.colorize, customColors, useOnlyCustomProps)
+  const objectColorizer = options.colorizeObjects
+    ? colorizer
+    : colors(false, [], false)
+
+  return {
+    EOL,
+    IDENT,
+    colorizer,
+    customColors,
+    customLevelNames,
+    customLevels,
+    customPrettifiers,
+    customProperties,
+    errorLikeObjectKeys,
+    errorProps,
+    getLevelLabelData,
+    hideObject,
+    ignoreKeys,
+    includeKeys,
+    levelFirst,
+    levelKey,
+    levelLabel,
+    messageFormat,
+    messageKey,
+    minimumLevel,
+    objectColorizer,
+    singleLine,
+    timestampKey,
+    translateTime,
+    useOnlyCustomProps
+  }
+}

package/node_modules/pino-pretty/lib/utils/prettify-error-log.js

@@ -0,0 +1,76 @@
+'use strict'
+
+module.exports = prettifyErrorLog
+
+const {
+  LOGGER_KEYS
+} = require('../constants')
+
+const isObject = require('./is-object')
+const joinLinesWithIndentation = require('./join-lines-with-indentation')
+const prettifyObject = require('./prettify-object')
+const stripUnsafeControlChars = require('./strip-unsafe-control-chars')
+
+/**
+ * @typedef {object} PrettifyErrorLogParams
+ * @property {object} log The error log to prettify.
+ * @property {PrettyContext} context The context object built from parsing
+ * the options.
+ */
+
+/**
+ * Given a log object that has a `type: 'Error'` key, prettify the object and
+ * return the result. In other
+ *
+ * @param {PrettifyErrorLogParams} input
+ *
+ * @returns {string} A string that represents the prettified error log.
+ */
+function prettifyErrorLog ({ log, context }) {
+  const {
+    EOL: eol,
+    IDENT: ident,
+    errorProps: errorProperties,
+    messageKey
+  } = context
+  const stack = stripUnsafeControlChars(log.stack)
+  const joinedLines = joinLinesWithIndentation({ input: stack, ident, eol })
+  let result = `${ident}${joinedLines}${eol}`
+
+  if (errorProperties.length > 0) {
+    const excludeProperties = LOGGER_KEYS.concat(messageKey, 'type', 'stack')
+    let propertiesToPrint
+    if (errorProperties[0] === '*') {
+      // Print all sibling properties except for the standard exclusions.
+      propertiesToPrint = Object.keys(log).filter(k => excludeProperties.includes(k) === false)
+    } else {
+      // Print only specified properties unless the property is a standard exclusion.
+      propertiesToPrint = errorProperties.filter(k => excludeProperties.includes(k) === false)
+    }
+
+    for (let i = 0; i < propertiesToPrint.length; i += 1) {
+      const key = propertiesToPrint[i]
+      if (key in log === false) continue
+      const safeKey = stripUnsafeControlChars(key)
+      if (isObject(log[key])) {
+        // The nested object may have "logger" type keys but since they are not
+        // at the root level of the object being processed, we want to print them.
+        // Thus, we invoke with `excludeLoggerKeys: false`.
+        const prettifiedObject = prettifyObject({
+          log: log[key],
+          excludeLoggerKeys: false,
+          context: {
+            ...context,
+            IDENT: ident + ident
+          }
+        })
+        result = `${result}${ident}${safeKey}: {${eol}${prettifiedObject}${ident}}${eol}`
+        continue
+      }
+      const value = stripUnsafeControlChars(log[key])
+      result = `${result}${ident}${safeKey}: ${value}${eol}`
+    }
+  }
+
+  return result
+}