@wbce/projen-d9 0.0.28 → 0.1.0

package/node_modules/pino-pretty/lib/utils/prettify-metadata.js

@@ -0,0 +1,75 @@
+'use strict'
+
+module.exports = prettifyMetadata
+
+const stripUnsafeControlChars = require('./strip-unsafe-control-chars')
+
+/**
+ * @typedef {object} PrettifyMetadataParams
+ * @property {object} log The log that may or may not contain metadata to
+ * be prettified.
+ * @property {PrettyContext} context The context object built from parsing
+ * the options.
+ */
+
+/**
+ * Prettifies metadata that is usually present in a Pino log line. It looks for
+ * fields `name`, `pid`, `hostname`, and `caller` and returns a formatted string using
+ * the fields it finds.
+ *
+ * @param {PrettifyMetadataParams} input
+ *
+ * @returns {undefined|string} If no metadata is found then `undefined` is
+ * returned. Otherwise, a string of prettified metadata is returned.
+ */
+function prettifyMetadata ({ log, context }) {
+  const { customPrettifiers: prettifiers, colorizer } = context
+  let line = ''
+
+  if (log.name || log.pid || log.hostname) {
+    line += '('
+
+    if (log.name) {
+      line += prettifiers.name
+        ? prettifiers.name(log.name, 'name', log, { colors: colorizer.colors })
+        : stripUnsafeControlChars(log.name)
+    }
+
+    if (log.pid) {
+      const prettyPid = prettifiers.pid
+        ? prettifiers.pid(log.pid, 'pid', log, { colors: colorizer.colors })
+        : stripUnsafeControlChars(log.pid)
+      if (log.name && log.pid) {
+        line += '/' + prettyPid
+      } else {
+        line += prettyPid
+      }
+    }
+
+    if (log.hostname) {
+      // If `pid` and `name` were in the ignore keys list then we don't need
+      // the leading space.
+      const prettyHostname = prettifiers.hostname
+        ? prettifiers.hostname(log.hostname, 'hostname', log, { colors: colorizer.colors })
+        : stripUnsafeControlChars(log.hostname)
+
+      line += `${line === '(' ? 'on' : ' on'} ${prettyHostname}`
+    }
+
+    line += ')'
+  }
+
+  if (log.caller) {
+    const prettyCaller = prettifiers.caller
+      ? prettifiers.caller(log.caller, 'caller', log, { colors: colorizer.colors })
+      : stripUnsafeControlChars(log.caller)
+
+    line += `${line === '' ? '' : ' '}<${prettyCaller}>`
+  }
+
+  if (line === '') {
+    return undefined
+  } else {
+    return line
+  }
+}

package/node_modules/pino-pretty/lib/utils/prettify-metadata.test.js

@@ -0,0 +1,170 @@
+'use strict'
+
+const { test } = require('node:test')
+const prettifyMetadata = require('./prettify-metadata')
+const getColorizer = require('../colors')
+const context = {
+  customPrettifiers: {},
+  colorizer: {
+    colors: {}
+  }
+}
+
+test('returns `undefined` if no metadata present', t => {
+  const str = prettifyMetadata({ log: {}, context })
+  t.assert.strictEqual(str, undefined)
+})
+
+test('works with only `name` present', t => {
+  const str = prettifyMetadata({ log: { name: 'foo' }, context })
+  t.assert.strictEqual(str, '(foo)')
+})
+
+test('works with only `pid` present', t => {
+  const str = prettifyMetadata({ log: { pid: '1234' }, context })
+  t.assert.strictEqual(str, '(1234)')
+})
+
+test('works with only `hostname` present', t => {
+  const str = prettifyMetadata({ log: { hostname: 'bar' }, context })
+  t.assert.strictEqual(str, '(on bar)')
+})
+
+test('works with only `name` & `pid` present', t => {
+  const str = prettifyMetadata({ log: { name: 'foo', pid: '1234' }, context })
+  t.assert.strictEqual(str, '(foo/1234)')
+})
+
+test('works with only `name` & `hostname` present', t => {
+  const str = prettifyMetadata({ log: { name: 'foo', hostname: 'bar' }, context })
+  t.assert.strictEqual(str, '(foo on bar)')
+})
+
+test('works with only `pid` & `hostname` present', t => {
+  const str = prettifyMetadata({ log: { pid: '1234', hostname: 'bar' }, context })
+  t.assert.strictEqual(str, '(1234 on bar)')
+})
+
+test('works with only `name`, `pid`, & `hostname` present', t => {
+  const str = prettifyMetadata({ log: { name: 'foo', pid: '1234', hostname: 'bar' }, context })
+  t.assert.strictEqual(str, '(foo/1234 on bar)')
+})
+
+test('works with only `name` & `caller` present', t => {
+  const str = prettifyMetadata({ log: { name: 'foo', caller: 'baz' }, context })
+  t.assert.strictEqual(str, '(foo) <baz>')
+})
+
+test('works with only `pid` & `caller` present', t => {
+  const str = prettifyMetadata({ log: { pid: '1234', caller: 'baz' }, context })
+  t.assert.strictEqual(str, '(1234) <baz>')
+})
+
+test('works with only `hostname` & `caller` present', t => {
+  const str = prettifyMetadata({ log: { hostname: 'bar', caller: 'baz' }, context })
+  t.assert.strictEqual(str, '(on bar) <baz>')
+})
+
+test('works with only `name`, `pid`, & `caller` present', t => {
+  const str = prettifyMetadata({ log: { name: 'foo', pid: '1234', caller: 'baz' }, context })
+  t.assert.strictEqual(str, '(foo/1234) <baz>')
+})
+
+test('works with only `name`, `hostname`, & `caller` present', t => {
+  const str = prettifyMetadata({ log: { name: 'foo', hostname: 'bar', caller: 'baz' }, context })
+  t.assert.strictEqual(str, '(foo on bar) <baz>')
+})
+
+test('works with only `caller` present', t => {
+  const str = prettifyMetadata({ log: { caller: 'baz' }, context })
+  t.assert.strictEqual(str, '<baz>')
+})
+
+test('works with only `pid`, `hostname`, & `caller` present', t => {
+  const str = prettifyMetadata({ log: { pid: '1234', hostname: 'bar', caller: 'baz' }, context })
+  t.assert.strictEqual(str, '(1234 on bar) <baz>')
+})
+
+test('works with all four present', t => {
+  const str = prettifyMetadata({ log: { name: 'foo', pid: '1234', hostname: 'bar', caller: 'baz' }, context })
+  t.assert.strictEqual(str, '(foo/1234 on bar) <baz>')
+})
+
+test('strips unsafe control characters from default metadata', t => {
+  const str = prettifyMetadata({
+    log: {
+      name: 'foo\u001B[2J',
+      pid: '1234\u0007',
+      hostname: 'bar\u009B[3J',
+      caller: 'baz\u007F'
+    },
+    context
+  })
+  t.assert.strictEqual(str, '(foo[2J/1234 on bar[3J) <baz>')
+})
+
+test('strips unsafe control characters after metadata values are coerced', t => {
+  const str = prettifyMetadata({
+    log: { name: ['foo\u001B[2J'] },
+    context
+  })
+  t.assert.strictEqual(str, '(foo[2J)')
+})
+
+test('uses prettifiers from passed prettifiers object', t => {
+  const prettifiers = {
+    name (input) {
+      return input.toUpperCase()
+    },
+    pid (input) {
+      return input + '__'
+    },
+    hostname (input) {
+      return input.toUpperCase()
+    },
+    caller (input) {
+      return input.toUpperCase()
+    }
+  }
+  const str = prettifyMetadata({
+    log: { pid: '1234', hostname: 'bar', caller: 'baz', name: 'joe' },
+    context: {
+      customPrettifiers: prettifiers,
+      colorizer: { colors: {} }
+    }
+  })
+  t.assert.strictEqual(str, '(JOE/1234__ on BAR) <BAZ>')
+})
+
+test('uses colorizer from passed context to colorize metadata', t => {
+  const prettifiers = {
+    name (input, _key, _log, { colors }) {
+      return colors.blue(input)
+    },
+    pid (input, _key, _log, { colors }) {
+      return colors.red(input)
+    },
+    hostname (input, _key, _log, { colors }) {
+      return colors.green(input)
+    },
+    caller (input, _key, _log, { colors }) {
+      return colors.cyan(input)
+    }
+  }
+  const log = { name: 'foo', pid: '1234', hostname: 'bar', caller: 'baz' }
+  const colorizer = getColorizer(true)
+  const context = {
+    customPrettifiers: prettifiers,
+    colorizer
+  }
+
+  const result = prettifyMetadata({ log, context })
+
+  const colorizedName = colorizer.colors.blue(log.name)
+  const colorizedPid = colorizer.colors.red(log.pid)
+  const colorizedHostname = colorizer.colors.green(log.hostname)
+  const colorizedCaller = colorizer.colors.cyan(log.caller)
+  const expected = `(${colorizedName}/${colorizedPid} on ${colorizedHostname}) <${colorizedCaller}>`
+
+  t.assert.strictEqual(result, expected)
+})

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

@@ -0,0 +1,115 @@
+'use strict'
+
+module.exports = prettifyObject
+
+const {
+  LOGGER_KEYS
+} = require('../constants')
+
+const stringifySafe = require('fast-safe-stringify')
+const joinLinesWithIndentation = require('./join-lines-with-indentation')
+const prettifyError = require('./prettify-error')
+const stripUnsafeControlChars = require('./strip-unsafe-control-chars')
+
+/**
+ * @typedef {object} PrettifyObjectParams
+ * @property {object} log The object to prettify.
+ * @property {boolean} [excludeLoggerKeys] Indicates if known logger specific
+ * keys should be excluded from prettification. Default: `true`.
+ * @property {string[]} [skipKeys] A set of object keys to exclude from the
+ *  * prettified result. Default: `[]`.
+ * @property {PrettyContext} context The context object built from parsing
+ * the options.
+ */
+
+/**
+ * Prettifies a standard object. Special care is taken when processing the object
+ * to handle child objects that are attached to keys known to contain error
+ * objects.
+ *
+ * @param {PrettifyObjectParams} input
+ *
+ * @returns {string} The prettified string. This can be as little as `''` if
+ * there was nothing to prettify.
+ */
+function prettifyObject ({
+  log,
+  excludeLoggerKeys = true,
+  skipKeys = [],
+  context
+}) {
+  const {
+    EOL: eol,
+    IDENT: ident,
+    customPrettifiers,
+    errorLikeObjectKeys: errorLikeKeys,
+    objectColorizer,
+    singleLine,
+    colorizer
+  } = context
+  const keysToIgnore = [].concat(skipKeys)
+
+  /* istanbul ignore else */
+  if (excludeLoggerKeys === true) Array.prototype.push.apply(keysToIgnore, LOGGER_KEYS)
+
+  let result = ''
+
+  // Split object keys into two categories: error and non-error
+  const { plain, errors } = Object.entries(log).reduce(({ plain, errors }, [k, v]) => {
+    if (keysToIgnore.includes(k) === false) {
+      // Pre-apply custom prettifiers, because all 3 cases below will need this
+      const pretty = typeof customPrettifiers[k] === 'function'
+        ? customPrettifiers[k](v, k, log, { colors: colorizer.colors })
+        : v
+      if (errorLikeKeys.includes(k)) {
+        errors[k] = pretty
+      } else {
+        plain[k] = pretty
+      }
+    }
+    return { plain, errors }
+  }, { plain: {}, errors: {} })
+
+  if (singleLine) {
+    // Stringify the entire object as a single JSON line
+    /* istanbul ignore else */
+    if (Object.keys(plain).length > 0) {
+      result += objectColorizer.greyMessage(stringifySafe(plain))
+    }
+    result += eol
+    // Avoid printing the escape character on escaped backslashes.
+    result = result.replace(/\\\\/gi, '\\')
+  } else {
+    // Put each object entry on its own line
+    Object.entries(plain).forEach(([keyName, keyValue]) => {
+      // custom prettifiers are already applied above, so we can skip it now
+      let lines = typeof customPrettifiers[keyName] === 'function'
+        ? keyValue
+        : stringifySafe(keyValue, null, 2)
+
+      if (lines === undefined) return
+
+      // Avoid printing the escape character on escaped backslashes.
+      lines = lines.replace(/\\\\/gi, '\\')
+
+      const joinedLines = joinLinesWithIndentation({ input: lines, ident, eol })
+      const safeKeyName = stripUnsafeControlChars(keyName)
+      result += `${ident}${objectColorizer.property(safeKeyName)}:${joinedLines.startsWith(eol) ? '' : ' '}${joinedLines}${eol}`
+    })
+  }
+
+  // Errors
+  Object.entries(errors).forEach(([keyName, keyValue]) => {
+    // custom prettifiers are already applied above, so we can skip it now
+    const hasCustomPrettifier = typeof customPrettifiers[keyName] === 'function'
+    const lines = hasCustomPrettifier
+      ? keyValue
+      : stringifySafe(keyValue, null, 2)
+
+    if (lines === undefined) return
+
+    result += prettifyError({ keyName, lines, eol, ident, sanitizeStack: !hasCustomPrettifier })
+  })
+
+  return result
+}

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

@@ -0,0 +1,217 @@
+'use strict'
+
+const { test } = require('node:test')
+const stringifySafe = require('fast-safe-stringify')
+const colors = require('../colors')
+const prettifyObject = require('./prettify-object')
+const {
+  ERROR_LIKE_KEYS
+} = require('../constants')
+
+const context = {
+  EOL: '\n',
+  IDENT: '    ',
+  customPrettifiers: {},
+  errorLikeObjectKeys: ERROR_LIKE_KEYS,
+  objectColorizer: colors(),
+  singleLine: false,
+  colorizer: colors()
+}
+
+test('returns empty string if no properties present', t => {
+  const str = prettifyObject({ log: {}, context })
+  t.assert.strictEqual(str, '')
+})
+
+test('works with single level properties', t => {
+  const str = prettifyObject({ log: { foo: 'bar' }, context })
+  t.assert.strictEqual(str, '    foo: "bar"\n')
+})
+
+test('strips unsafe control characters from property names', t => {
+  const str = prettifyObject({ log: { 'foo\u001B[2J\u009B[3J': 'bar' }, context })
+  t.assert.strictEqual(str, '    foo[2J[3J: "bar"\n')
+})
+
+test('works with multiple level properties', t => {
+  const str = prettifyObject({ log: { foo: { bar: 'baz' } }, context })
+  t.assert.strictEqual(str, '    foo: {\n      "bar": "baz"\n    }\n')
+})
+
+test('skips specified keys', t => {
+  const str = prettifyObject({
+    log: { foo: 'bar', hello: 'world' },
+    skipKeys: ['foo'],
+    context
+  })
+  t.assert.strictEqual(str, '    hello: "world"\n')
+})
+
+test('ignores predefined keys', t => {
+  const str = prettifyObject({ log: { foo: 'bar', pid: 12345 }, context })
+  t.assert.strictEqual(str, '    foo: "bar"\n')
+})
+
+test('ignores escaped backslashes in string values', t => {
+  const str = prettifyObject({ log: { foo_regexp: '\\[^\\w\\s]\\' }, context })
+  t.assert.strictEqual(str, '    foo_regexp: "\\[^\\w\\s]\\"\n')
+})
+
+test('ignores escaped backslashes in string values (singleLine option)', t => {
+  const str = prettifyObject({
+    log: { foo_regexp: '\\[^\\w\\s]\\' },
+    context: {
+      ...context,
+      singleLine: true
+    }
+  })
+  t.assert.strictEqual(str, '{"foo_regexp":"\\[^\\w\\s]\\"}\n')
+})
+
+test('works with error props', t => {
+  const err = Error('Something went wrong')
+  const serializedError = {
+    message: err.message,
+    stack: err.stack
+  }
+  const str = prettifyObject({ log: { error: serializedError }, context })
+  t.assert.ok(str.startsWith('    error:'))
+  t.assert.ok(str.includes('     "message": "Something went wrong",'))
+  t.assert.ok(str.includes('         Error: Something went wrong'))
+})
+
+test('customPrettifiers gets applied', t => {
+  const customPrettifiers = {
+    foo: v => v.toUpperCase()
+  }
+  const str = prettifyObject({
+    log: { foo: 'foo' },
+    context: {
+      ...context,
+      customPrettifiers
+    }
+  })
+  t.assert.strictEqual(str.startsWith('    foo: FOO'), true)
+})
+
+test('skips lines omitted by customPrettifiers', t => {
+  const customPrettifiers = {
+    foo: () => { return undefined }
+  }
+  const str = prettifyObject({
+    log: { foo: 'foo', bar: 'bar' },
+    context: {
+      ...context,
+      customPrettifiers
+    }
+  })
+  t.assert.strictEqual(str.includes('bar: "bar"'), true)
+  t.assert.strictEqual(str.includes('foo: "foo"'), false)
+})
+
+test('joined lines omits starting eol', t => {
+  const str = prettifyObject({
+    log: { msg: 'doing work', calls: ['step 1', 'step 2', 'step 3'], level: 30 },
+    context: {
+      ...context,
+      IDENT: '',
+      customPrettifiers: {
+        calls: val => '\n' + val.map(it => '  ' + it).join('\n')
+      }
+    }
+  })
+  t.assert.strictEqual(str, [
+    'msg: "doing work"',
+    'calls:',
+    '  step 1',
+    '  step 2',
+    '  step 3',
+    ''
+  ].join('\n'))
+})
+
+test('errors skips prettifiers', t => {
+  const customPrettifiers = {
+    err: () => { return 'is_err' }
+  }
+  const str = prettifyObject({
+    log: { err: Error('boom') },
+    context: {
+      ...context,
+      customPrettifiers
+    }
+  })
+  t.assert.strictEqual(str.includes('err: is_err'), true)
+})
+
+test('preserves control characters produced by a custom error prettifier', t => {
+  const colorizer = colors(true)
+  const customPrettifiers = {
+    err: (_value, _key, _log, { colors }) => stringifySafe({
+      stack: colors.red('Error: boom')
+    }, null, 2)
+  }
+  const str = prettifyObject({
+    log: { err: Error('boom') },
+    context: {
+      ...context,
+      colorizer,
+      customPrettifiers
+    }
+  })
+  t.assert.strictEqual(str.includes(colorizer.colors.red('Error: boom')), true)
+})
+
+test('errors skips prettifying if no lines are present', t => {
+  const customPrettifiers = {
+    err: () => { return undefined }
+  }
+  const str = prettifyObject({
+    log: { err: Error('boom') },
+    context: {
+      ...context,
+      customPrettifiers
+    }
+  })
+  t.assert.strictEqual(str, '')
+})
+
+test('works with single level properties', t => {
+  const colorizer = colors(true)
+  const str = prettifyObject({
+    log: { foo: 'bar' },
+    context: {
+      ...context,
+      objectColorizer: colorizer,
+      colorizer
+    }
+  })
+  t.assert.strictEqual(str, `    ${colorizer.colors.magenta('foo')}: "bar"\n`)
+})
+
+test('works with customColors', t => {
+  const colorizer = colors(true, [])
+  t.assert.doesNotThrow(() => {
+    prettifyObject({
+      log: { foo: 'bar' },
+      context: {
+        ...context,
+        objectColorizer: colorizer,
+        colorizer
+      }
+    })
+  })
+})
+
+test('customColors gets applied', t => {
+  const colorizer = colors(true, [['property', 'green']])
+  const str = prettifyObject({
+    log: { foo: 'bar' },
+    context: {
+      ...context,
+      objectColorizer: colorizer,
+      colorizer
+    }
+  })
+  t.assert.strictEqual(str, `    ${colorizer.colors.green('foo')}: "bar"\n`)
+})

package/node_modules/pino-pretty/lib/utils/prettify-time.js

@@ -0,0 +1,43 @@
+'use strict'
+
+module.exports = prettifyTime
+
+const formatTime = require('./format-time')
+const stripUnsafeControlChars = require('./strip-unsafe-control-chars')
+
+/**
+ * @typedef {object} PrettifyTimeParams
+ * @property {object} log The log object with the timestamp to be prettified.
+ * @property {PrettyContext} context The context object built from parsing
+ * the options.
+ */
+
+/**
+ * Prettifies a timestamp if the given `log` has either `time`, `timestamp` or custom specified timestamp
+ * property.
+ *
+ * @param {PrettifyTimeParams} input
+ *
+ * @returns {undefined|string} If a timestamp property cannot be found then
+ * `undefined` is returned. Otherwise, the prettified time is returned as a
+ * string.
+ */
+function prettifyTime ({ log, context }) {
+  const {
+    timestampKey,
+    translateTime: translateFormat
+  } = context
+  const prettifier = context.customPrettifiers?.time
+  let time = null
+
+  if (timestampKey in log) {
+    time = log[timestampKey]
+  } else if ('timestamp' in log) {
+    time = log.timestamp
+  }
+
+  if (time === null) return undefined
+  const output = translateFormat ? formatTime(time, translateFormat) : time
+
+  return prettifier ? prettifier(output) : `[${stripUnsafeControlChars(output)}]`
+}