@wbce/projen-d9 0.0.28 → 0.1.0

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

@@ -0,0 +1,171 @@
+'use strict'
+
+module.exports = pretty
+
+const sjs = require('secure-json-parse')
+
+const isObject = require('./utils/is-object')
+const prettifyErrorLog = require('./utils/prettify-error-log')
+const prettifyLevel = require('./utils/prettify-level')
+const prettifyMessage = require('./utils/prettify-message')
+const prettifyMetadata = require('./utils/prettify-metadata')
+const prettifyObject = require('./utils/prettify-object')
+const prettifyTime = require('./utils/prettify-time')
+const filterLog = require('./utils/filter-log')
+
+const {
+  LEVELS,
+  LEVEL_KEY,
+  LEVEL_NAMES
+} = require('./constants')
+
+const jsonParser = input => {
+  try {
+    return { value: sjs.parse(input, { protoAction: 'remove' }) }
+  } catch (err) {
+    return { err }
+  }
+}
+
+/**
+ * Orchestrates processing the received log data according to the provided
+ * configuration and returns a prettified log string.
+ *
+ * @typedef {function} LogPrettifierFunc
+ * @param {string|object} inputData A log string or a log-like object.
+ * @returns {string} A string that represents the prettified log data.
+ */
+function pretty (inputData) {
+  let log
+  if (!isObject(inputData)) {
+    const parsed = jsonParser(inputData)
+    if (parsed.err || !isObject(parsed.value)) {
+      // pass through
+      return inputData + this.EOL
+    }
+    log = parsed.value
+  } else {
+    log = inputData
+  }
+
+  if (this.minimumLevel) {
+    // We need to figure out if the custom levels has the desired minimum
+    // level & use that one if found. If not, determine if the level exists
+    // in the standard levels. In both cases, make sure we have the level
+    // number instead of the level name.
+    let condition
+    if (this.useOnlyCustomProps) {
+      condition = this.customLevels
+    } else {
+      condition = this.customLevelNames[this.minimumLevel] !== undefined
+    }
+    let minimum
+    if (condition) {
+      minimum = this.customLevelNames[this.minimumLevel]
+    } else {
+      minimum = LEVEL_NAMES[this.minimumLevel]
+    }
+    if (!minimum) {
+      minimum = typeof this.minimumLevel === 'string'
+        ? LEVEL_NAMES[this.minimumLevel]
+        : LEVEL_NAMES[LEVELS[this.minimumLevel].toLowerCase()]
+    }
+
+    const level = log[this.levelKey === undefined ? LEVEL_KEY : this.levelKey]
+    if (level < minimum) return
+  }
+
+  const prettifiedMessage = prettifyMessage({ log, context: this.context })
+
+  if (this.ignoreKeys || this.includeKeys) {
+    log = filterLog({ log, context: this.context })
+  }
+
+  const prettifiedLevel = prettifyLevel({
+    log,
+    context: {
+      ...this.context,
+      // This is odd. The colorizer ends up relying on the value of
+      // `customProperties` instead of the original `customLevels` and
+      // `customLevelNames`.
+      ...this.context.customProperties
+    }
+  })
+  const prettifiedMetadata = prettifyMetadata({ log, context: this.context })
+  const prettifiedTime = prettifyTime({ log, context: this.context })
+
+  let line = ''
+  if (this.levelFirst && prettifiedLevel) {
+    line = `${prettifiedLevel}`
+  }
+
+  if (prettifiedTime && line === '') {
+    line = `${prettifiedTime}`
+  } else if (prettifiedTime) {
+    line = `${line} ${prettifiedTime}`
+  }
+
+  if (!this.levelFirst && prettifiedLevel) {
+    if (line.length > 0) {
+      line = `${line} ${prettifiedLevel}`
+    } else {
+      line = prettifiedLevel
+    }
+  }
+
+  if (prettifiedMetadata) {
+    if (line.length > 0) {
+      line = `${line} ${prettifiedMetadata}:`
+    } else {
+      line = prettifiedMetadata
+    }
+  }
+
+  if (line.endsWith(':') === false && line !== '') {
+    line += ':'
+  }
+
+  if (prettifiedMessage !== undefined) {
+    if (line.length > 0) {
+      line = `${line} ${prettifiedMessage}`
+    } else {
+      line = prettifiedMessage
+    }
+  }
+
+  if (line.length > 0 && !this.singleLine) {
+    line += this.EOL
+  }
+
+  // pino@7+ does not log this anymore
+  if (log.type === 'Error' && typeof log.stack === 'string') {
+    const prettifiedErrorLog = prettifyErrorLog({ log, context: this.context })
+    if (this.singleLine) line += this.EOL
+    line += prettifiedErrorLog
+  } else if (this.hideObject === false) {
+    const skipKeys = [
+      this.messageKey,
+      this.levelKey,
+      this.timestampKey
+    ]
+      .map((key) => key.replaceAll(/\\/g, ''))
+      .filter(key => {
+        return typeof log[key] === 'string' ||
+          typeof log[key] === 'number' ||
+          typeof log[key] === 'boolean'
+      })
+    const prettifiedObject = prettifyObject({
+      log,
+      skipKeys,
+      context: this.context
+    })
+
+    // In single line mode, include a space only if prettified version isn't empty
+    if (this.singleLine && !/^\s$/.test(prettifiedObject)) {
+      line += ' '
+    }
+    line += prettifiedObject
+  }
+
+  return line
+}

package/node_modules/pino-pretty/lib/utils/build-safe-sonic-boom.js

@@ -0,0 +1,69 @@
+'use strict'
+
+module.exports = buildSafeSonicBoom
+
+const { isMainThread } = require('node:worker_threads')
+const SonicBoom = require('sonic-boom')
+const noop = require('./noop')
+
+/**
+ * Creates a safe SonicBoom instance
+ *
+ * @param {object} opts Options for SonicBoom
+ *
+ * @returns {object} A new SonicBoom stream
+ */
+function buildSafeSonicBoom (opts) {
+  const stream = new SonicBoom(opts)
+  stream.on('error', filterBrokenPipe)
+  // if we are sync: false, we must flush on exit
+  if (!opts.sync && isMainThread) {
+    setupOnExit(stream)
+  }
+  return stream
+
+  function filterBrokenPipe (err) {
+    if (err.code === 'EPIPE') {
+      stream.write = noop
+      stream.end = noop
+      stream.flushSync = noop
+      stream.destroy = noop
+      return
+    }
+    stream.removeListener('error', filterBrokenPipe)
+  }
+}
+
+function setupOnExit (stream) {
+  /* istanbul ignore next */
+  if (global.WeakRef && global.WeakMap && global.FinalizationRegistry) {
+    // This is leak free, it does not leave event handlers
+    const onExit = require('on-exit-leak-free')
+
+    onExit.register(stream, autoEnd)
+
+    stream.on('close', function () {
+      onExit.unregister(stream)
+    })
+  }
+}
+
+/* istanbul ignore next */
+function autoEnd (stream, eventName) {
+  // This check is needed only on some platforms
+
+  if (stream.destroyed) {
+    return
+  }
+
+  if (eventName === 'beforeExit') {
+    // We still have an event loop, let's use it
+    stream.flush()
+    stream.on('drain', function () {
+      stream.end()
+    })
+  } else {
+    // We do not have an event loop, so flush synchronously
+    stream.flushSync()
+  }
+}

package/node_modules/pino-pretty/lib/utils/build-safe-sonic-boom.test.js

@@ -0,0 +1,84 @@
+'use strict'
+
+const { test } = require('node:test')
+const { rimraf } = require('rimraf')
+const fs = require('node:fs')
+const { join } = require('node:path')
+
+const buildSafeSonicBoom = require('./build-safe-sonic-boom')
+
+const file = () => {
+  const dest = join(__dirname, `${process.pid}-${process.hrtime().toString()}`)
+  const fd = fs.openSync(dest, 'w')
+  return { dest, fd }
+}
+
+test('should not write when error emitted and code is "EPIPE"', t => {
+  t.plan(1)
+
+  const { fd, dest } = file()
+  const stream = buildSafeSonicBoom({ sync: true, fd, mkdir: true })
+  t.after(() => rimraf(dest))
+
+  stream.emit('error', { code: 'EPIPE' })
+  stream.write('will not work')
+
+  const dataFile = fs.readFileSync(dest)
+  t.assert.strictEqual(dataFile.length, 0)
+})
+
+test('should stream.write works when error code is not "EPIPE"', t => {
+  t.plan(3)
+  const { fd, dest } = file()
+  const stream = buildSafeSonicBoom({ sync: true, fd, mkdir: true })
+
+  t.after(() => rimraf(dest))
+
+  stream.on('error', () => t.assert.ok('error emitted'))
+
+  stream.emit('error', 'fake error description')
+
+  t.assert.ok(stream.write('will work'))
+
+  const dataFile = fs.readFileSync(dest)
+  t.assert.strictEqual(dataFile.toString(), 'will work')
+})
+
+test('cover setupOnExit', async t => {
+  t.plan(3)
+  const { fd, dest } = file()
+  const stream = buildSafeSonicBoom({ sync: false, fd, mkdir: true })
+
+  t.after(() => rimraf(dest))
+
+  stream.on('error', () => t.assert.ok('error emitted'))
+  stream.emit('error', 'fake error description')
+
+  t.assert.ok(stream.write('will work'))
+
+  await watchFileCreated(dest)
+
+  const dataFile = fs.readFileSync(dest)
+  t.assert.strictEqual(dataFile.toString(), 'will work')
+})
+
+function watchFileCreated (filename) {
+  return new Promise((resolve, reject) => {
+    const TIMEOUT = 2000
+    const INTERVAL = 100
+    const threshold = TIMEOUT / INTERVAL
+    let counter = 0
+    const interval = setInterval(() => {
+      // On some CI runs file is created but not filled
+      if (fs.existsSync(filename) && fs.statSync(filename).size !== 0) {
+        clearInterval(interval)
+        resolve()
+      } else if (counter <= threshold) {
+        counter++
+      } else {
+        clearInterval(interval)
+        reject(new Error(`${filename} was not created.`))
+      }
+    }, INTERVAL)
+  })
+}

package/node_modules/pino-pretty/lib/utils/create-date.js

@@ -0,0 +1,26 @@
+'use strict'
+
+module.exports = createDate
+
+const isValidDate = require('./is-valid-date')
+
+/**
+ * Constructs a JS Date from a number or string. Accepts any single number
+ * or single string argument that is valid for the Date() constructor,
+ * or an epoch as a string.
+ *
+ * @param {string|number} epoch The representation of the Date.
+ *
+ * @returns {Date} The constructed Date.
+ */
+function createDate (epoch) {
+  // If epoch is already a valid argument, return the valid Date
+  let date = new Date(epoch)
+  if (isValidDate(date)) {
+    return date
+  }
+
+  // Convert to a number to permit epoch as a string
+  date = new Date(+epoch)
+  return date
+}

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

@@ -0,0 +1,20 @@
+'use strict'
+
+const { test } = require('node:test')
+const createDate = require('./create-date')
+
+const wanted = 1624450038567
+
+test('accepts arguments the Date constructor would accept', t => {
+  t.plan(2)
+  t.assert.strictEqual(createDate(1624450038567).getTime(), wanted)
+  t.assert.strictEqual(createDate('2021-06-23T12:07:18.567Z').getTime(), wanted)
+})
+
+test('accepts epoch as a string', t => {
+  // If Date() accepts this argument, the createDate function is not needed
+  // and can be replaced with Date()
+  t.plan(2)
+  t.assert.notEqual(new Date('16244500385-67').getTime(), wanted)
+  t.assert.strictEqual(createDate('1624450038567').getTime(), wanted)
+})

package/node_modules/pino-pretty/lib/utils/delete-log-property.js

@@ -0,0 +1,28 @@
+'use strict'
+
+module.exports = deleteLogProperty
+
+const getPropertyValue = require('./get-property-value')
+const splitPropertyKey = require('./split-property-key')
+
+/**
+ * Deletes a specified property from a log object if it exists.
+ * This function mutates the passed in `log` object.
+ *
+ * @param {object} log The log object to be modified.
+ * @param {string} property A string identifying the property to be deleted from
+ * the log 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'`
+ */
+function deleteLogProperty (log, property) {
+  const props = splitPropertyKey(property)
+  const propToDelete = props.pop()
+
+  log = getPropertyValue(log, props)
+
+  /* istanbul ignore else */
+  if (log !== null && typeof log === 'object' && Object.prototype.hasOwnProperty.call(log, propToDelete)) {
+    delete log[propToDelete]
+  }
+}

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

@@ -0,0 +1,31 @@
+'use strict'
+
+const { test } = require('node:test')
+const { createCopier } = require('fast-copy')
+const fastCopy = createCopier({})
+const deleteLogProperty = require('./delete-log-property')
+
+const logData = {
+  level: 30,
+  data1: {
+    data2: { 'data-3': 'bar' }
+  }
+}
+
+test('deleteLogProperty deletes property of depth 1', t => {
+  const log = fastCopy(logData)
+  deleteLogProperty(log, 'data1')
+  t.assert.deepStrictEqual(log, { level: 30 })
+})
+
+test('deleteLogProperty deletes property of depth 2', t => {
+  const log = fastCopy(logData)
+  deleteLogProperty(log, 'data1.data2')
+  t.assert.deepStrictEqual(log, { level: 30, data1: { } })
+})
+
+test('deleteLogProperty deletes property of depth 3', t => {
+  const log = fastCopy(logData)
+  deleteLogProperty(log, 'data1.data2.data-3')
+  t.assert.deepStrictEqual(log, { level: 30, data1: { data2: { } } })
+})

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

@@ -0,0 +1,99 @@
+'use strict'
+
+module.exports = filterLog
+
+const { createCopier } = require('fast-copy')
+const fastCopy = createCopier({})
+
+const deleteLogProperty = require('./delete-log-property')
+const getPropertyValue = require('./get-property-value')
+const splitPropertyKey = require('./split-property-key')
+
+/**
+ * @typedef {object} FilterLogParams
+ * @property {object} log The log object to be modified.
+ * @property {PrettyContext} context The context object built from parsing
+ * the options.
+ */
+
+/**
+ * True when every segment of a (possibly nested) property path exists.
+ *
+ * @param {object} log
+ * @param {string} property
+ * @returns {boolean}
+ */
+function hasLogProperty (log, property) {
+  const props = splitPropertyKey(property)
+  if (props.length === 0) {
+    return false
+  }
+  let current = log
+
+  for (const prop of props) {
+    if (current === null || typeof current !== 'object' || !Object.prototype.hasOwnProperty.call(current, prop)) {
+      return false
+    }
+    current = current[prop]
+  }
+
+  return true
+}
+
+/**
+ * Assigns `value` at a (possibly nested) property path, creating intermediate
+ * objects as needed. Nested keys use the same `.` / `\.` rules as ignore.
+ *
+ * @param {object} log
+ * @param {string} property
+ * @param {*} value
+ */
+function setLogProperty (log, property, value) {
+  const props = splitPropertyKey(property)
+  const last = props.pop()
+  let current = log
+
+  for (const prop of props) {
+    if (current[prop] === null || typeof current[prop] !== 'object') {
+      current[prop] = {}
+    }
+    current = current[prop]
+  }
+
+  current[last] = value
+}
+
+/**
+ * Filter a log object by removing or including keys accordingly.
+ * When `includeKeys` is passed, `ignoredKeys` will be ignored.
+ * One of ignoreKeys or includeKeys must be pass in.
+ *
+ * Nested keys (e.g. `user.id`) are supported for both include and ignore,
+ * including escaped dots in property names.
+ *
+ * @param {FilterLogParams} input
+ *
+ * @returns {object} A new `log` object instance that
+ *  either only includes the keys in includeKeys
+ *  or does not include those in ignoredKeys.
+ */
+function filterLog ({ log, context }) {
+  const { ignoreKeys, includeKeys } = context
+  const logCopy = fastCopy(log)
+
+  if (includeKeys) {
+    const logIncluded = {}
+
+    includeKeys.forEach((key) => {
+      if (hasLogProperty(logCopy, key)) {
+        setLogProperty(logIncluded, key, getPropertyValue(logCopy, key))
+      }
+    })
+    return logIncluded
+  }
+
+  ignoreKeys.forEach((ignoreKey) => {
+    deleteLogProperty(logCopy, ignoreKey)
+  })
+  return logCopy
+}