@wbce/projen-d9 0.0.28 → 0.1.0

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

@@ -0,0 +1,265 @@
+'use strict'
+
+const { describe, test } = require('node:test')
+const filterLog = require('./filter-log')
+
+const context = {
+  includeKeys: undefined,
+  ignoreKeys: undefined
+}
+const logData = {
+  level: 30,
+  time: 1522431328992,
+  data1: {
+    data2: { 'data-3': 'bar' },
+    error: new Error('test')
+  }
+}
+const logData2 = Object.assign({
+  'logging.domain.corp/operation': {
+    id: 'foo',
+    producer: 'bar'
+  }
+}, logData)
+
+describe('#filterLog with an ignoreKeys option', () => {
+  test('filterLog removes single entry', t => {
+    const result = filterLog({
+      log: logData,
+      context: {
+        ...context,
+        ignoreKeys: ['data1.data2.data-3']
+      }
+    })
+    t.assert.deepStrictEqual(result, { level: 30, time: 1522431328992, data1: { data2: { }, error: new Error('test') } })
+  })
+
+  test('filterLog removes multiple entries', t => {
+    const result = filterLog({
+      log: logData,
+      context: {
+        ...context,
+        ignoreKeys: ['time', 'data1']
+      }
+    })
+    t.assert.deepStrictEqual(result, { level: 30 })
+  })
+
+  test('filterLog keeps error instance', t => {
+    const result = filterLog({
+      log: logData,
+      context: {
+        ...context,
+        ignoreKeys: []
+      }
+    })
+    t.assert.strictEqual(logData.data1.error, result.data1.error)
+  })
+
+  test('filterLog removes entry with escape sequence', t => {
+    const result = filterLog({
+      log: logData2,
+      context: {
+        ...context,
+        ignoreKeys: ['data1', 'logging\\.domain\\.corp/operation']
+      }
+    })
+    t.assert.deepStrictEqual(result, { level: 30, time: 1522431328992 })
+  })
+
+  test('filterLog removes entry with escape sequence nested', t => {
+    const result = filterLog({
+      log: logData2,
+      context: {
+        ...context,
+        ignoreKeys: ['data1', 'logging\\.domain\\.corp/operation.producer']
+      }
+    })
+    t.assert.deepStrictEqual(result, { level: 30, time: 1522431328992, 'logging.domain.corp/operation': { id: 'foo' } })
+  })
+})
+
+for (const ignoreKeys of [
+  undefined,
+  ['level'],
+  ['level', 'data1.data2.data-3']
+]) {
+  describe(`#filterLog with an includeKeys option when the ignoreKeys being ${ignoreKeys}`, () => {
+    test('filterLog include nothing', t => {
+      const result = filterLog({
+        log: logData,
+        context: {
+          ...context,
+          ignoreKeys,
+          includeKeys: []
+        }
+      })
+      t.assert.deepStrictEqual(result, {})
+    })
+
+    test('filterLog include empty key is a no-op', t => {
+      const result = filterLog({
+        log: logData,
+        context: {
+          ...context,
+          ignoreKeys,
+          includeKeys: ['']
+        }
+      })
+      t.assert.deepStrictEqual(result, {})
+    })
+
+    test('filterLog include single entry', t => {
+      const result = filterLog({
+        log: logData,
+        context: {
+          ...context,
+          ignoreKeys,
+          includeKeys: ['time']
+        }
+      })
+      t.assert.deepStrictEqual(result, { time: 1522431328992 })
+    })
+
+    test('filterLog include multiple entries', t => {
+      const result = filterLog({
+        log: logData,
+        context: {
+          ...context,
+          ignoreKeys,
+          includeKeys: ['time', 'data1']
+        }
+      })
+      t.assert.deepStrictEqual(result, {
+        time: 1522431328992,
+        data1: {
+          data2: { 'data-3': 'bar' },
+          error: new Error('test')
+        }
+      })
+    })
+
+    test('filterLog include nested entry', t => {
+      const result = filterLog({
+        log: logData,
+        context: {
+          ...context,
+          ignoreKeys,
+          includeKeys: ['data1.data2.data-3']
+        }
+      })
+      t.assert.deepStrictEqual(result, { data1: { data2: { 'data-3': 'bar' } } })
+    })
+
+    test('filterLog include nested and top-level entries', t => {
+      const result = filterLog({
+        log: logData,
+        context: {
+          ...context,
+          ignoreKeys,
+          includeKeys: ['time', 'data1.data2.data-3']
+        }
+      })
+      t.assert.deepStrictEqual(result, {
+        time: 1522431328992,
+        data1: { data2: { 'data-3': 'bar' } }
+      })
+    })
+
+    test('filterLog include missing nested entry', t => {
+      const result = filterLog({
+        log: logData,
+        context: {
+          ...context,
+          ignoreKeys,
+          includeKeys: ['data1.missing']
+        }
+      })
+      t.assert.deepStrictEqual(result, {})
+    })
+  })
+}
+
+describe('#filterLog includeKeys with escaped nested keys', () => {
+  test('filterLog include escaped top-level key', t => {
+    const result = filterLog({
+      log: logData2,
+      context: {
+        ...context,
+        includeKeys: ['logging\\.domain\\.corp/operation']
+      }
+    })
+    t.assert.deepStrictEqual(result, {
+      'logging.domain.corp/operation': {
+        id: 'foo',
+        producer: 'bar'
+      }
+    })
+  })
+
+  test('filterLog include escaped nested key', t => {
+    const result = filterLog({
+      log: logData2,
+      context: {
+        ...context,
+        includeKeys: ['logging\\.domain\\.corp/operation.producer']
+      }
+    })
+    t.assert.deepStrictEqual(result, {
+      'logging.domain.corp/operation': { producer: 'bar' }
+    })
+  })
+})
+
+describe('#filterLog with circular references', () => {
+  const logData = {
+    level: 30,
+    time: 1522431328992,
+    data1: 'test'
+  }
+  logData.circular = logData
+
+  test('filterLog removes single entry', t => {
+    const result = filterLog({
+      log: logData,
+      context: {
+        ...context,
+        ignoreKeys: ['data1']
+      }
+    })
+
+    t.assert.deepStrictEqual(result.circular.level, result.level)
+    t.assert.deepStrictEqual(result.circular.time, result.time)
+
+    delete result.circular
+    t.assert.deepStrictEqual(result, { level: 30, time: 1522431328992 })
+  })
+
+  test('filterLog includes single entry', t => {
+    const result = filterLog({
+      log: logData,
+      context: {
+        ...context,
+        includeKeys: ['data1']
+      }
+    })
+
+    t.assert.deepStrictEqual(result, { data1: 'test' })
+  })
+
+  test('filterLog includes circular keys', t => {
+    const result = filterLog({
+      log: logData,
+      context: {
+        ...context,
+        includeKeys: ['level', 'circular']
+      }
+    })
+
+    t.assert.deepStrictEqual(result.circular.level, logData.level)
+    t.assert.deepStrictEqual(result.circular.time, logData.time)
+
+    delete result.circular
+    t.assert.deepStrictEqual(result, { level: 30 })
+  })
+})

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

@@ -0,0 +1,66 @@
+'use strict'
+
+module.exports = formatTime
+
+const {
+  DATE_FORMAT,
+  DATE_FORMAT_SIMPLE
+} = require('../constants')
+
+const dateformat = require('dateformat')
+const createDate = require('./create-date')
+const isValidDate = require('./is-valid-date')
+
+/**
+ * Converts a given `epoch` to a desired display format.
+ *
+ * @param {number|string} epoch The time to convert. May be any value that is
+ * valid for `new Date()`.
+ * @param {boolean|string} [translateTime=false] When `false`, the given `epoch`
+ * will simply be returned. When `true`, the given `epoch` will be converted
+ * to a string at UTC using the `DATE_FORMAT_SIMPLE` constant. If `translateTime` is
+ * a string, the following rules are available:
+ *
+ * - `<format string>`: The string is a literal format string. This format
+ * string will be used to interpret the `epoch` and return a display string
+ * at UTC.
+ * - `SYS:STANDARD`: The returned display string will follow the `DATE_FORMAT`
+ * constant at the system's local timezone.
+ * - `SYS:<format string>`: The returned display string will follow the given
+ * `<format string>` at the system's local timezone.
+ * - `UTC:<format string>`: The returned display string will follow the given
+ * `<format string>` at UTC.
+ *
+ * @returns {number|string} The formatted time.
+ */
+function formatTime (epoch, translateTime = false) {
+  if (translateTime === false) {
+    return epoch
+  }
+
+  const instant = createDate(epoch)
+
+  // If the Date is invalid, do not attempt to format
+  if (!isValidDate(instant)) {
+    return epoch
+  }
+
+  if (translateTime === true) {
+    return dateformat(instant, DATE_FORMAT_SIMPLE)
+  }
+
+  const upperFormat = translateTime.toUpperCase()
+  if (upperFormat === 'SYS:STANDARD') {
+    return dateformat(instant, DATE_FORMAT)
+  }
+
+  const prefix = upperFormat.substr(0, 4)
+  if (prefix === 'SYS:' || prefix === 'UTC:') {
+    if (prefix === 'UTC:') {
+      return dateformat(instant, translateTime)
+    }
+    return dateformat(instant, translateTime.slice(4))
+  }
+
+  return dateformat(instant, `UTC:${translateTime}`)
+}

package/node_modules/pino-pretty/lib/utils/format-time.test.js

@@ -0,0 +1,71 @@
+'use strict'
+
+process.env.TZ = 'UTC'
+
+const { test } = require('node:test')
+const formatTime = require('./format-time')
+
+const dateStr = '2019-04-06T13:30:00.000-04:00'
+const epoch = new Date(dateStr)
+const epochMS = epoch.getTime()
+
+test('passes through epoch if `translateTime` is `false`', t => {
+  const formattedTime = formatTime(epochMS)
+  t.assert.strictEqual(formattedTime, epochMS)
+})
+
+test('passes through epoch if date is invalid', t => {
+  const input = 'this is not a date'
+  const formattedTime = formatTime(input, true)
+  t.assert.strictEqual(formattedTime, input)
+})
+
+test('translates epoch milliseconds if `translateTime` is `true`', t => {
+  const formattedTime = formatTime(epochMS, true)
+  t.assert.strictEqual(formattedTime, '17:30:00.000')
+})
+
+test('translates epoch milliseconds to UTC string given format', t => {
+  const formattedTime = formatTime(epochMS, 'd mmm yyyy H:MM')
+  t.assert.strictEqual(formattedTime, '6 Apr 2019 17:30')
+})
+
+test('translates epoch milliseconds to SYS:STANDARD', t => {
+  const formattedTime = formatTime(epochMS, 'SYS:STANDARD')
+  t.assert.match(formattedTime, /\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} [-+]?\d{4}/)
+})
+
+test('translates epoch milliseconds to SYS:<FORMAT>', t => {
+  const formattedTime = formatTime(epochMS, 'SYS:d mmm yyyy H:MM')
+  t.assert.match(formattedTime, /\d{1} \w{3} \d{4} \d{1,2}:\d{2}/)
+})
+
+test('passes through date string if `translateTime` is `false`', t => {
+  const formattedTime = formatTime(dateStr)
+  t.assert.strictEqual(formattedTime, dateStr)
+})
+
+test('translates date string if `translateTime` is `true`', t => {
+  const formattedTime = formatTime(dateStr, true)
+  t.assert.strictEqual(formattedTime, '17:30:00.000')
+})
+
+test('translates date string to UTC string given format', t => {
+  const formattedTime = formatTime(dateStr, 'd mmm yyyy H:MM')
+  t.assert.strictEqual(formattedTime, '6 Apr 2019 17:30')
+})
+
+test('translates date string to SYS:STANDARD', t => {
+  const formattedTime = formatTime(dateStr, 'SYS:STANDARD')
+  t.assert.match(formattedTime, /\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} [-+]?\d{4}/)
+})
+
+test('translates date string to UTC:<FORMAT>', t => {
+  const formattedTime = formatTime(dateStr, 'UTC:d mmm yyyy H:MM')
+  t.assert.strictEqual(formattedTime, '6 Apr 2019 17:30')
+})
+
+test('translates date string to SYS:<FORMAT>', t => {
+  const formattedTime = formatTime(dateStr, 'SYS:d mmm yyyy H:MM')
+  t.assert.match(formattedTime, /\d{1} \w{3} \d{4} \d{1,2}:\d{2}/)
+})

package/node_modules/pino-pretty/lib/utils/get-level-label-data.js

@@ -0,0 +1,29 @@
+'use strict'
+
+module.exports = getLevelLabelData
+const { LEVELS, LEVEL_NAMES } = require('../constants')
+
+/**
+ * Given initial settings for custom levels/names and use of only custom props
+ * get the level label that corresponds with a given level number
+ *
+ * @param {boolean} useOnlyCustomProps
+ * @param {object} customLevels
+ * @param {object} customLevelNames
+ *
+ * @returns {function} A function that takes a number level and returns the level's label string
+ */
+function getLevelLabelData (useOnlyCustomProps, customLevels, customLevelNames) {
+  const levels = useOnlyCustomProps ? customLevels || LEVELS : Object.assign({}, LEVELS, customLevels)
+  const levelNames = useOnlyCustomProps ? customLevelNames || LEVEL_NAMES : Object.assign({}, LEVEL_NAMES, customLevelNames)
+  return function (level) {
+    let levelNum = 'default'
+    if (Number.isInteger(+level)) {
+      levelNum = Object.prototype.hasOwnProperty.call(levels, level) ? level : levelNum
+    } else {
+      levelNum = Object.prototype.hasOwnProperty.call(levelNames, level.toLowerCase()) ? levelNames[level.toLowerCase()] : levelNum
+    }
+
+    return [levels[levelNum], levelNum]
+  }
+}

package/node_modules/pino-pretty/lib/utils/get-property-value.js

@@ -0,0 +1,30 @@
+'use strict'
+
+module.exports = getPropertyValue
+
+const splitPropertyKey = require('./split-property-key')
+
+/**
+ * Gets a specified property from an object if it exists.
+ *
+ * @param {object} obj The object to be searched.
+ * @param {string|string[]} property A string, or an array of strings, identifying
+ * the property to be retrieved from the object.
+ * Accepts nested properties delimited by a `.`.
+ * Delimiter can be escaped to preserve property names that contain the delimiter.
+ * e.g. `'prop1.prop2'` or `'prop2\.domain\.corp.prop2'`.
+ *
+ * @returns {*}
+ */
+function getPropertyValue (obj, property) {
+  const props = Array.isArray(property) ? property : splitPropertyKey(property)
+
+  for (const prop of props) {
+    if (!Object.prototype.hasOwnProperty.call(obj, prop)) {
+      return
+    }
+    obj = obj[prop]
+  }
+
+  return obj
+}

package/node_modules/pino-pretty/lib/utils/get-property-value.test.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const { test } = require('node:test')
+const getPropertyValue = require('./get-property-value')
+
+test('getPropertyValue returns the value of the property', t => {
+  const result = getPropertyValue({
+    foo: 'bar'
+  }, 'foo')
+  t.assert.strictEqual(result, 'bar')
+})
+
+test('getPropertyValue returns the value of the nested property', t => {
+  const result = getPropertyValue({ extra: { foo: { value: 'bar' } } }, 'extra.foo.value')
+  t.assert.strictEqual(result, 'bar')
+})
+
+test('getPropertyValue returns the value of the nested property using the array of nested property keys', t => {
+  const result = getPropertyValue({ extra: { foo: { value: 'bar' } } }, ['extra', 'foo', 'value'])
+  t.assert.strictEqual(result, 'bar')
+})
+
+test('getPropertyValue returns undefined for non-existing properties', t => {
+  const result = getPropertyValue({ extra: { foo: { value: 'bar' } } }, 'extra.foo.value-2')
+  t.assert.strictEqual(result, undefined)
+})
+
+test('getPropertyValue returns undefined for non-existing properties using the array of nested property keys', t => {
+  const result = getPropertyValue({ extra: { foo: { value: 'bar' } } }, ['extra', 'foo', 'value-2'])
+  t.assert.strictEqual(result, undefined)
+})

package/node_modules/pino-pretty/lib/utils/handle-custom-levels-names-opts.js

@@ -0,0 +1,38 @@
+'use strict'
+
+module.exports = handleCustomLevelsNamesOpts
+
+/**
+ * Parse a CSV string or options object that maps level
+ * labels to level values.
+ *
+ * @param {string|object} cLevels An object mapping level
+ * names to level values, e.g. `{ info: 30, debug: 65 }`, or a
+ * CSV string in the format `level_name:level_value`, e.g.
+ * `info:30,debug:65`.
+ *
+ * @returns {object} An object mapping levels names to level values
+ * e.g. `{ info: 30, debug: 65 }`.
+ */
+function handleCustomLevelsNamesOpts (cLevels) {
+  if (!cLevels) return {}
+
+  if (typeof cLevels === 'string') {
+    return cLevels
+      .split(',')
+      .reduce((agg, value, idx) => {
+        const [levelName, levelNum = idx] = value.split(':')
+        agg[levelName.toLowerCase()] = levelNum
+        return agg
+      }, {})
+  } else if (Object.prototype.toString.call(cLevels) === '[object Object]') {
+    return Object
+      .keys(cLevels)
+      .reduce((agg, levelName) => {
+        agg[levelName.toLowerCase()] = cLevels[levelName]
+        return agg
+      }, {})
+  } else {
+    return {}
+  }
+}

package/node_modules/pino-pretty/lib/utils/handle-custom-levels-names-opts.test.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const { test } = require('node:test')
+const match = require('@jsumners/assert-match')
+const handleCustomLevelsNamesOpts = require('./handle-custom-levels-names-opts')
+
+test('returns a empty object `{}` for undefined parameter', t => {
+  const handledCustomLevelNames = handleCustomLevelsNamesOpts()
+  t.assert.deepStrictEqual(handledCustomLevelNames, {})
+})
+
+test('returns a empty object `{}` for unknown parameter', t => {
+  const handledCustomLevelNames = handleCustomLevelsNamesOpts(123)
+  t.assert.deepStrictEqual(handledCustomLevelNames, {})
+})
+
+test('returns a filled object for string parameter', t => {
+  const handledCustomLevelNames = handleCustomLevelsNamesOpts('ok:10,warn:20,error:35')
+  match(handledCustomLevelNames, {
+    ok: 10,
+    warn: 20,
+    error: 35
+  }, t)
+})
+
+test('returns a filled object for object parameter', t => {
+  const handledCustomLevelNames = handleCustomLevelsNamesOpts({
+    ok: 10,
+    warn: 20,
+    error: 35
+  })
+  match(handledCustomLevelNames, {
+    ok: 10,
+    warn: 20,
+    error: 35
+  }, t)
+})
+
+test('defaults missing level num to first index', t => {
+  const result = handleCustomLevelsNamesOpts('ok:10,info')
+  match(result, {
+    ok: 10,
+    info: 1
+  }, t)
+})

package/node_modules/pino-pretty/lib/utils/handle-custom-levels-opts.js

@@ -0,0 +1,39 @@
+'use strict'
+
+module.exports = handleCustomLevelsOpts
+
+/**
+ * Parse a CSV string or options object that specifies
+ * configuration for custom levels.
+ *
+ * @param {string|object} cLevels An object mapping level
+ * names to values, e.g. `{ info: 30, debug: 65 }`, or a
+ * CSV string in the format `level_name:level_value`, e.g.
+ * `info:30,debug:65`.
+ *
+ * @returns {object} An object mapping levels to labels that
+ * appear in logs, e.g. `{ '30': 'INFO', '65': 'DEBUG' }`.
+ */
+function handleCustomLevelsOpts (cLevels) {
+  if (!cLevels) return {}
+
+  if (typeof cLevels === 'string') {
+    return cLevels
+      .split(',')
+      .reduce((agg, value, idx) => {
+        const [levelName, levelNum = idx] = value.split(':')
+        agg[levelNum] = levelName.toUpperCase()
+        return agg
+      },
+      { default: 'USERLVL' })
+  } else if (Object.prototype.toString.call(cLevels) === '[object Object]') {
+    return Object
+      .keys(cLevels)
+      .reduce((agg, levelName) => {
+        agg[cLevels[levelName]] = levelName.toUpperCase()
+        return agg
+      }, { default: 'USERLVL' })
+  } else {
+    return {}
+  }
+}

package/node_modules/pino-pretty/lib/utils/handle-custom-levels-opts.test.js

@@ -0,0 +1,47 @@
+'use strict'
+
+const { test } = require('node:test')
+const handleCustomLevelsOpts = require('./handle-custom-levels-opts')
+
+test('returns a empty object `{}` for undefined parameter', t => {
+  const handledCustomLevel = handleCustomLevelsOpts()
+  t.assert.deepStrictEqual(handledCustomLevel, {})
+})
+
+test('returns a empty object `{}` for unknown parameter', t => {
+  const handledCustomLevel = handleCustomLevelsOpts(123)
+  t.assert.deepStrictEqual(handledCustomLevel, {})
+})
+
+test('returns a filled object for string parameter', t => {
+  const handledCustomLevel = handleCustomLevelsOpts('ok:10,warn:20,error:35')
+  t.assert.deepStrictEqual(handledCustomLevel, {
+    10: 'OK',
+    20: 'WARN',
+    35: 'ERROR',
+    default: 'USERLVL'
+  })
+})
+
+test('returns a filled object for object parameter', t => {
+  const handledCustomLevel = handleCustomLevelsOpts({
+    ok: 10,
+    warn: 20,
+    error: 35
+  })
+  t.assert.deepStrictEqual(handledCustomLevel, {
+    10: 'OK',
+    20: 'WARN',
+    35: 'ERROR',
+    default: 'USERLVL'
+  })
+})
+
+test('defaults missing level num to first index', t => {
+  const result = handleCustomLevelsOpts('ok:10,info')
+  t.assert.deepStrictEqual(result, {
+    10: 'OK',
+    1: 'INFO',
+    default: 'USERLVL'
+  })
+})