@wbce/projen-d9 0.0.28 → 0.1.0

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

@@ -0,0 +1,143 @@
+'use strict'
+
+const { test, describe } = require('node:test')
+const prettifyErrorLog = require('./prettify-error-log')
+const colors = require('../colors')
+const {
+  ERROR_LIKE_KEYS,
+  MESSAGE_KEY
+} = require('../constants')
+
+const context = {
+  EOL: '\n',
+  IDENT: '    ',
+  customPrettifiers: {},
+  errorLikeObjectKeys: ERROR_LIKE_KEYS,
+  errorProps: [],
+  messageKey: MESSAGE_KEY,
+  objectColorizer: colors()
+}
+
+test('returns string with default settings', t => {
+  const err = Error('Something went wrong')
+  const str = prettifyErrorLog({ log: err, context })
+  t.assert.ok(str.startsWith('    Error: Something went wrong'))
+})
+
+test('strips unsafe control characters from the stack', t => {
+  const err = Error('Something went wrong')
+  err.stack = 'Error: bad\u001B[2J\n    at location\u009B[3J'
+  const str = prettifyErrorLog({ log: err, context })
+  t.assert.strictEqual(str, '    Error: bad[2J\n        at location[3J\n')
+})
+
+test('returns string with custom ident', t => {
+  const err = Error('Something went wrong')
+  const str = prettifyErrorLog({
+    log: err,
+    context: {
+      ...context,
+      IDENT: '  '
+    }
+  })
+  t.assert.ok(str.startsWith('  Error: Something went wrong'))
+})
+
+test('returns string with custom eol', t => {
+  const err = Error('Something went wrong')
+  const str = prettifyErrorLog({
+    log: err,
+    context: {
+      ...context,
+      EOL: '\r\n'
+    }
+  })
+  t.assert.ok(str.startsWith('    Error: Something went wrong\r\n'))
+})
+
+describe('errorProperties', () => {
+  test('excludes all for wildcard', t => {
+    const err = Error('boom')
+    err.foo = 'foo'
+    const str = prettifyErrorLog({
+      log: err,
+      context: {
+        ...context,
+        errorProps: ['*']
+      }
+    })
+    t.assert.ok(str.startsWith('    Error: boom'))
+    t.assert.strictEqual(str.includes('foo: "foo"'), false)
+  })
+
+  test('excludes only selected properties', t => {
+    const err = Error('boom')
+    err.foo = 'foo'
+    const str = prettifyErrorLog({
+      log: err,
+      context: {
+        ...context,
+        errorProps: ['foo']
+      }
+    })
+    t.assert.ok(str.startsWith('    Error: boom'))
+    t.assert.strictEqual(str.includes('foo: foo'), true)
+  })
+
+  test('ignores specified properties if not present', t => {
+    const err = Error('boom')
+    err.foo = 'foo'
+    const str = prettifyErrorLog({
+      log: err,
+      context: {
+        ...context,
+        errorProps: ['foo', 'bar']
+      }
+    })
+    t.assert.ok(str.startsWith('    Error: boom'))
+    t.assert.strictEqual(str.includes('foo: foo'), true)
+    t.assert.strictEqual(str.includes('bar'), false)
+  })
+
+  test('processes nested objects', t => {
+    const err = Error('boom')
+    err.foo = { bar: 'bar', message: 'included' }
+    const str = prettifyErrorLog({
+      log: err,
+      context: {
+        ...context,
+        errorProps: ['foo']
+      }
+    })
+    t.assert.ok(str.startsWith('    Error: boom'))
+    t.assert.strictEqual(str.includes('foo: {'), true)
+    t.assert.strictEqual(str.includes('bar: "bar"'), true)
+    t.assert.strictEqual(str.includes('message: "included"'), true)
+  })
+
+  test('strips unsafe control characters from primitive property names and values', t => {
+    const err = Error('boom')
+    err['detail\u001B[2J'] = 'hidden\u009B[3J'
+    const str = prettifyErrorLog({
+      log: err,
+      context: {
+        ...context,
+        errorProps: ['*']
+      }
+    })
+    t.assert.strictEqual(str.includes('detail[2J: hidden[3J'), true)
+  })
+
+  test('strips unsafe control characters after primitive properties are coerced', t => {
+    const err = Error('boom')
+    err.detail = ['hidden\u001B[2J']
+    const str = prettifyErrorLog({
+      log: err,
+      context: {
+        ...context,
+        errorProps: ['detail']
+      }
+    })
+    t.assert.strictEqual(str.includes('detail: hidden[2J'), true)
+  })
+})

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

@@ -0,0 +1,54 @@
+'use strict'
+
+module.exports = prettifyError
+
+const joinLinesWithIndentation = require('./join-lines-with-indentation')
+const stripUnsafeControlChars = require('./strip-unsafe-control-chars')
+
+/**
+ * @typedef {object} PrettifyErrorParams
+ * @property {string} keyName The key assigned to this error in the log object.
+ * @property {string} lines The STRINGIFIED error. If the error field has a
+ *  custom prettifier, that should be pre-applied as well.
+ * @property {string} ident The indentation sequence to use.
+ * @property {string} eol The EOL sequence to use.
+ * @property {boolean} [sanitizeStack=true] Whether to sanitize the decoded stack.
+ */
+
+/**
+ * Prettifies an error string into a multi-line format.
+ *
+ * @param {PrettifyErrorParams} input
+ *
+ * @returns {string}
+ */
+function prettifyError ({ keyName, lines, eol, ident, sanitizeStack = true }) {
+  let result = ''
+  const joinedLines = joinLinesWithIndentation({ input: lines, ident, eol })
+  const safeKeyName = stripUnsafeControlChars(keyName)
+  const splitLines = `${ident}${safeKeyName}: ${joinedLines}${eol}`.split(eol)
+
+  for (let j = 0; j < splitLines.length; j += 1) {
+    if (j !== 0) result += eol
+
+    const line = splitLines[j]
+    if (/^\s*"stack"/.test(line)) {
+      const matches = /^(\s*"stack":)\s*(".*"),?$/.exec(line)
+      /* istanbul ignore else */
+      if (matches && matches.length === 3) {
+        const indentSize = /^\s*/.exec(line)[0].length + 4
+        const indentation = ' '.repeat(indentSize)
+        const stackMessage = matches[2]
+        const parsedStack = JSON.parse(stackMessage)
+        const stack = sanitizeStack ? stripUnsafeControlChars(parsedStack) : parsedStack
+        result += matches[1] + eol + indentation + stack.replace(/\n/g, eol + indentation)
+      } else {
+        result += line
+      }
+    } else {
+      result += line
+    }
+  }
+
+  return result
+}

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

@@ -0,0 +1,25 @@
+'use strict'
+
+const { test } = require('node:test')
+const stringifySafe = require('fast-safe-stringify')
+const prettifyError = require('./prettify-error')
+
+test('prettifies error', t => {
+  const error = Error('Bad error!')
+  const lines = stringifySafe(error, Object.getOwnPropertyNames(error), 2)
+
+  const prettyError = prettifyError({ keyName: 'errorKey', lines, ident: '    ', eol: '\n' })
+  t.assert.match(prettyError, /\s*errorKey: {\n\s*"stack":[\s\S]*"message": "Bad error!"/)
+})
+
+test('strips unsafe control characters from an error stack', t => {
+  const lines = stringifySafe({
+    stack: 'Error: bad\u001B[2J\n    at location\u009B[3J',
+    message: 'bad'
+  }, null, 2)
+
+  const prettyError = prettifyError({ keyName: 'errorKey', lines, ident: '    ', eol: '\n' })
+  t.assert.strictEqual(prettyError.includes('\u001B'), false)
+  t.assert.strictEqual(prettyError.includes('\u009B'), false)
+  t.assert.match(prettyError, /Error: bad\[2J\n\s+at location\[3J/)
+})

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

@@ -0,0 +1,41 @@
+'use strict'
+
+module.exports = prettifyLevel
+
+const getPropertyValue = require('./get-property-value')
+
+/**
+ * @typedef {object} PrettifyLevelParams
+ * @property {object} log The log object.
+ * @property {PrettyContext} context The context object built from parsing
+ * the options.
+ */
+
+/**
+ * Checks if the passed in log has a `level` value and returns a prettified
+ * string for that level if so.
+ *
+ * @param {PrettifyLevelParams} input
+ *
+ * @returns {undefined|string} If `log` does not have a `level` property then
+ * `undefined` will be returned. Otherwise, a string from the specified
+ * `colorizer` is returned.
+ */
+function prettifyLevel ({ log, context }) {
+  const {
+    colorizer,
+    customLevels,
+    customLevelNames,
+    levelKey,
+    getLevelLabelData
+  } = context
+  const prettifier = context.customPrettifiers?.level
+  const output = getPropertyValue(log, levelKey)
+  if (output === undefined) return undefined
+  const labelColorized = colorizer(output, { customLevels, customLevelNames })
+  if (prettifier) {
+    const [label] = getLevelLabelData(output)
+    return prettifier(output, levelKey, log, { label, labelColorized, colors: colorizer.colors })
+  }
+  return labelColorized
+}

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

@@ -0,0 +1,70 @@
+'use strict'
+
+const { test } = require('node:test')
+const prettifyLevel = require('./prettify-level')
+const getColorizer = require('../colors')
+const getLevelLabelData = require('./get-level-label-data')
+const {
+  LEVEL_KEY
+} = require('../constants')
+
+const context = {
+  colorizer: getColorizer(),
+  customLevelNames: undefined,
+  customLevels: undefined,
+  levelKey: LEVEL_KEY,
+  customPrettifiers: undefined,
+  getLevelLabelData: getLevelLabelData(false, {}, {})
+}
+
+test('returns `undefined` for unknown level', t => {
+  const colorized = prettifyLevel({
+    log: {},
+    context: {
+      ...context
+    }
+  })
+  t.assert.strictEqual(colorized, undefined)
+})
+
+test('returns non-colorized value for default colorizer', t => {
+  const log = {
+    level: 30
+  }
+  const colorized = prettifyLevel({
+    log,
+    context: {
+      ...context
+    }
+  })
+  t.assert.strictEqual(colorized, 'INFO')
+})
+
+test('returns colorized value for color colorizer', t => {
+  const log = {
+    level: 30
+  }
+  const colorizer = getColorizer(true)
+  const colorized = prettifyLevel({
+    log,
+    context: {
+      ...context,
+      colorizer
+    }
+  })
+  t.assert.strictEqual(colorized, '\u001B[32mINFO\u001B[39m')
+})
+
+test('passes output through provided prettifier', t => {
+  const log = {
+    level: 30
+  }
+  const colorized = prettifyLevel({
+    log,
+    context: {
+      ...context,
+      customPrettifiers: { level () { return 'modified' } }
+    }
+  })
+  t.assert.strictEqual(colorized, 'modified')
+})

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

@@ -0,0 +1,65 @@
+'use strict'
+
+module.exports = prettifyMessage
+
+const {
+  LEVELS
+} = require('../constants')
+
+const getPropertyValue = require('./get-property-value')
+const interpretConditionals = require('./interpret-conditionals')
+const stripUnsafeControlChars = require('./strip-unsafe-control-chars')
+
+/**
+ * @typedef {object} PrettifyMessageParams
+ * @property {object} log The log object with the message to colorize.
+ * @property {PrettyContext} context The context object built from parsing
+ * the options.
+ */
+
+/**
+ * Prettifies a message string if the given `log` has a message property.
+ *
+ * @param {PrettifyMessageParams} input
+ *
+ * @returns {undefined|string} If the message key is not found, or the message
+ * key is not a string, then `undefined` will be returned. Otherwise, a string
+ * that is the prettified message.
+ */
+function prettifyMessage ({ log, context }) {
+  const {
+    colorizer,
+    customLevels,
+    levelKey,
+    levelLabel,
+    messageFormat,
+    messageKey,
+    useOnlyCustomProps
+  } = context
+  if (messageFormat && typeof messageFormat === 'string') {
+    const parsedMessageFormat = interpretConditionals(messageFormat, log)
+
+    const message = String(parsedMessageFormat).replace(
+      /{([^{}]+)}/g,
+      function (match, p1) {
+        // return log level as string instead of int
+        let level
+        if (p1 === levelLabel && (level = getPropertyValue(log, levelKey)) !== undefined) {
+          const condition = useOnlyCustomProps ? customLevels === undefined : customLevels[level] === undefined
+          return condition ? LEVELS[level] : customLevels[level]
+        }
+
+        // Parse nested key access, e.g. `{keyA.subKeyB}`.
+        const value = getPropertyValue(log, p1)
+        return value !== undefined ? value : ''
+      })
+    return colorizer.message(stripUnsafeControlChars(message))
+  }
+  if (messageFormat && typeof messageFormat === 'function') {
+    const msg = messageFormat(log, messageKey, levelLabel, { colors: colorizer.colors })
+    return colorizer.message(msg)
+  }
+  if (messageKey in log === false) return undefined
+  if (typeof log[messageKey] !== 'string' && typeof log[messageKey] !== 'number' && typeof log[messageKey] !== 'boolean') return undefined
+  return colorizer.message(stripUnsafeControlChars(log[messageKey]))
+}

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

@@ -0,0 +1,287 @@
+'use strict'
+
+const { test } = require('node:test')
+const prettifyMessage = require('./prettify-message')
+const getColorizer = require('../colors')
+const {
+  LEVEL_KEY,
+  LEVEL_LABEL
+} = require('../constants')
+const context = {
+  colorizer: getColorizer(),
+  levelKey: LEVEL_KEY,
+  levelLabel: LEVEL_LABEL,
+  messageKey: 'msg'
+}
+
+test('returns `undefined` if `messageKey` not found', t => {
+  const str = prettifyMessage({ log: {}, context })
+  t.assert.strictEqual(str, undefined)
+})
+
+test('returns `undefined` if `messageKey` not string', t => {
+  const str = prettifyMessage({ log: { msg: {} }, context })
+  t.assert.strictEqual(str, undefined)
+})
+
+test('returns non-colorized value for default colorizer', t => {
+  const colorizer = getColorizer()
+  const str = prettifyMessage({
+    log: { msg: 'foo' },
+    context: { ...context, colorizer }
+  })
+  t.assert.strictEqual(str, 'foo')
+})
+
+test('returns non-colorized value for alternate `messageKey`', t => {
+  const str = prettifyMessage({
+    log: { message: 'foo' },
+    context: { ...context, messageKey: 'message' }
+  })
+  t.assert.strictEqual(str, 'foo')
+})
+
+test('returns colorized value for color colorizer', t => {
+  const colorizer = getColorizer(true)
+  const str = prettifyMessage({
+    log: { msg: 'foo' },
+    context: { ...context, colorizer }
+  })
+  t.assert.strictEqual(str, '\u001B[36mfoo\u001B[39m')
+})
+
+test('strips unsafe control characters before colorizing a message', t => {
+  const colorizer = getColorizer(true)
+  const str = prettifyMessage({
+    log: { msg: 'before\t\u001B[2Jafter\nnext\u009B[3J' },
+    context: { ...context, colorizer }
+  })
+  t.assert.strictEqual(str, '\u001B[36mbefore\t[2Jafter\nnext[3J\u001B[39m')
+})
+
+test('returns colorized value for color colorizer for alternate `messageKey`', t => {
+  const colorizer = getColorizer(true)
+  const str = prettifyMessage({
+    log: { message: 'foo' },
+    context: { ...context, messageKey: 'message', colorizer }
+  })
+  t.assert.strictEqual(str, '\u001B[36mfoo\u001B[39m')
+})
+
+test('returns message formatted by `messageFormat` option', t => {
+  const str = prettifyMessage({
+    log: { msg: 'foo', context: 'appModule' },
+    context: { ...context, messageFormat: '{context} - {msg}' }
+  })
+  t.assert.strictEqual(str, 'appModule - foo')
+})
+
+test('strips unsafe control characters substituted by a string `messageFormat`', t => {
+  const str = prettifyMessage({
+    log: { msg: 'foo\u0007', context: 'app\u007FModule' },
+    context: { ...context, messageFormat: '{context} - {msg}' }
+  })
+  t.assert.strictEqual(str, 'appModule - foo')
+})
+
+test('returns message formatted by `messageFormat` option - missing prop', t => {
+  const str = prettifyMessage({
+    log: { context: 'appModule' },
+    context: { ...context, messageFormat: '{context} - {msg}' }
+  })
+  t.assert.strictEqual(str, 'appModule - ')
+})
+
+test('returns message formatted by `messageFormat` option - levelLabel & useOnlyCustomProps false', t => {
+  const str = prettifyMessage({
+    log: { msg: 'foo', context: 'appModule', level: 30 },
+    context: {
+      ...context,
+      messageFormat: '[{level}] {levelLabel} {context} - {msg}',
+      customLevels: {}
+    }
+  })
+  t.assert.strictEqual(str, '[30] INFO appModule - foo')
+})
+
+test('returns message formatted by `messageFormat` option - levelLabel & useOnlyCustomProps true', t => {
+  const str = prettifyMessage({
+    log: { msg: 'foo', context: 'appModule', level: 30 },
+    context: {
+      ...context,
+      messageFormat: '[{level}] {levelLabel} {context} - {msg}',
+      customLevels: { 30: 'CHECK' },
+      useOnlyCustomProps: true
+    }
+  })
+  t.assert.strictEqual(str, '[30] CHECK appModule - foo')
+})
+
+test('returns message formatted by `messageFormat` option - levelLabel & customLevels', t => {
+  const str = prettifyMessage({
+    log: { msg: 'foo', context: 'appModule', level: 123 },
+    context: {
+      ...context,
+      messageFormat: '[{level}] {levelLabel} {context} - {msg}',
+      customLevels: { 123: 'CUSTOM' }
+    }
+  })
+  t.assert.strictEqual(str, '[123] CUSTOM appModule - foo')
+})
+
+test('returns message formatted by `messageFormat` option - levelLabel, customLevels & useOnlyCustomProps', t => {
+  const str = prettifyMessage({
+    log: { msg: 'foo', context: 'appModule', level: 123 },
+    context: {
+      ...context,
+      messageFormat: '[{level}] {levelLabel} {context} - {msg}',
+      customLevels: { 123: 'CUSTOM' },
+      useOnlyCustomProps: true
+    }
+  })
+  t.assert.strictEqual(str, '[123] CUSTOM appModule - foo')
+})
+
+test('returns message formatted by `messageFormat` option - levelLabel, customLevels & useOnlyCustomProps false', t => {
+  const str = prettifyMessage({
+    log: { msg: 'foo', context: 'appModule', level: 40 },
+    context: {
+      ...context,
+      messageFormat: '[{level}] {levelLabel} {context} - {msg}',
+      customLevels: { 123: 'CUSTOM' },
+      useOnlyCustomProps: false
+    }
+  })
+  t.assert.strictEqual(str, '[40] WARN appModule - foo')
+})
+
+test('returns message formatted by `messageFormat` option - value 0', t => {
+  const str = prettifyMessage({
+    log: { value: 0 },
+    context: { ...context, messageFormat: '{value}' },
+  })
+  t.assert.strictEqual(str, '0')
+})
+
+test('returns message formatted by `messageFormat` option - value false', t => {
+  const str = prettifyMessage({
+    log: { value: false },
+    context: { ...context, messageFormat: '{value}' },
+  })
+  t.assert.strictEqual(str, 'false')
+})
+
+test('returns message formatted by `messageFormat` option - value undefined', t => {
+  const str = prettifyMessage({
+    log: { value: undefined },
+    context: { ...context, messageFormat: '{value}' },
+  })
+  t.assert.strictEqual(str, '')
+})
+
+test('returns message formatted by `messageFormat` option - value null', t => {
+  const str = prettifyMessage({
+    log: { value: null },
+    context: { ...context, messageFormat: '{value}' },
+  })
+  t.assert.strictEqual(str, 'null')
+})
+
+test('`messageFormat` supports nested curly brackets', t => {
+  const str = prettifyMessage({
+    log: { level: 30 },
+    context: {
+      ...context,
+      messageFormat: '{{level}}-{level}-{{level}-{level}}'
+    }
+  })
+  t.assert.strictEqual(str, '{30}-30-{30-30}')
+})
+
+test('`messageFormat` supports nested object', t => {
+  const str = prettifyMessage({
+    log: { level: 30, request: { url: 'localhost/test' }, msg: 'foo' },
+    context: {
+      ...context,
+      messageFormat: '{request.url} - param: {request.params.process} - {msg}'
+    }
+  })
+  t.assert.strictEqual(str, 'localhost/test - param:  - foo')
+})
+
+test('`messageFormat` supports conditional blocks', t => {
+  const str = prettifyMessage({
+    log: { level: 30, req: { id: 'foo' } },
+    context: {
+      ...context,
+      messageFormat: '{level} | {if req.id}({req.id}){end}{if msg}{msg}{end}'
+    }
+  })
+  t.assert.strictEqual(str, '30 | (foo)')
+})
+
+test('`messageFormat` supports function definition', t => {
+  const str = prettifyMessage({
+    log: { level: 30, request: { url: 'localhost/test' }, msg: 'incoming request' },
+    context: {
+      ...context,
+      messageFormat: (log, messageKey, levelLabel) => {
+        let msg = log[messageKey]
+        if (msg === 'incoming request') msg = `--> ${log.request.url}`
+        return msg
+      }
+    }
+  })
+  t.assert.strictEqual(str, '--> localhost/test')
+})
+
+test('`messageFormat` supports function definition with colorizer object', t => {
+  const colorizer = getColorizer(true)
+  const str = prettifyMessage({
+    log: { level: 30, request: { url: 'localhost/test' }, msg: 'incoming request' },
+    context: {
+      ...context,
+      colorizer,
+      messageFormat: (log, messageKey, levelLabel, { colors }) => {
+        let msg = log[messageKey]
+        if (msg === 'incoming request') msg = `--> ${colors.red(log.request.url)}`
+        return msg
+      }
+    }
+  })
+  t.assert.strictEqual(str, '\u001B[36m--> \u001B[31mlocalhost/test\u001B[36m\u001B[39m')
+})
+
+test('`messageFormat` supports function definition with colorizer object when using custom colors', t => {
+  const colorizer = getColorizer(true, [[30, 'brightGreen']], false)
+  const str = prettifyMessage({
+    log: { level: 30, request: { url: 'localhost/test' }, msg: 'incoming request' },
+    context: {
+      ...context,
+      colorizer,
+      messageFormat: (log, messageKey, levelLabel, { colors }) => {
+        let msg = log[messageKey]
+        if (msg === 'incoming request') msg = `--> ${colors.red(log.request.url)}`
+        return msg
+      }
+    }
+  })
+  t.assert.strictEqual(str, '\u001B[36m--> \u001B[31mlocalhost/test\u001B[36m\u001B[39m')
+})
+
+test('`messageFormat` supports function definition with colorizer object when no color is supported', t => {
+  const colorizer = getColorizer(false)
+  const str = prettifyMessage({
+    log: { level: 30, request: { url: 'localhost/test' }, msg: 'incoming request' },
+    context: {
+      ...context,
+      colorizer,
+      messageFormat: (log, messageKey, levelLabel, { colors }) => {
+        let msg = log[messageKey]
+        if (msg === 'incoming request') msg = `--> ${colors.red(log.request.url)}`
+        return msg
+      }
+    }
+  })
+  t.assert.strictEqual(str, '--> localhost/test')
+})