@wbce/projen-d9 0.0.28 → 0.1.0

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

@@ -0,0 +1,264 @@
+'use strict'
+
+process.env.TZ = 'UTC'
+
+const { test } = require('node:test')
+const prettifyTime = require('./prettify-time')
+const {
+  TIMESTAMP_KEY
+} = require('../constants')
+const context = {
+  timestampKey: TIMESTAMP_KEY,
+  translateTime: true,
+  customPrettifiers: {}
+}
+
+test('returns `undefined` if `time` or `timestamp` not in log', t => {
+  const str = prettifyTime({ log: {}, context })
+  t.assert.strictEqual(str, undefined)
+})
+
+test('returns prettified formatted time from custom field', t => {
+  const log = { customtime: 1554642900000 }
+  let str = prettifyTime({
+    log,
+    context: {
+      ...context,
+      timestampKey: 'customtime'
+    }
+  })
+  t.assert.strictEqual(str, '[13:15:00.000]')
+
+  str = prettifyTime({
+    log,
+    context: {
+      ...context,
+      translateTime: false,
+      timestampKey: 'customtime'
+    }
+  })
+  t.assert.strictEqual(str, '[1554642900000]')
+})
+
+test('returns prettified formatted time', t => {
+  let log = { time: 1554642900000 }
+  let str = prettifyTime({
+    log,
+    context: {
+      ...context
+    }
+  })
+  t.assert.strictEqual(str, '[13:15:00.000]')
+
+  log = { timestamp: 1554642900000 }
+  str = prettifyTime({
+    log,
+    context: {
+      ...context
+    }
+  })
+  t.assert.strictEqual(str, '[13:15:00.000]')
+
+  log = { time: '2019-04-07T09:15:00.000-04:00' }
+  str = prettifyTime({
+    log,
+    context: {
+      ...context
+    }
+  })
+  t.assert.strictEqual(str, '[13:15:00.000]')
+
+  log = { timestamp: '2019-04-07T09:15:00.000-04:00' }
+  str = prettifyTime({
+    log,
+    context: {
+      ...context
+    }
+  })
+  t.assert.strictEqual(str, '[13:15:00.000]')
+
+  log = { time: 1554642900000 }
+  str = prettifyTime({
+    log,
+    context: {
+      ...context,
+      translateTime: 'd mmm yyyy H:MM'
+    }
+  })
+  t.assert.strictEqual(str, '[7 Apr 2019 13:15]')
+
+  log = { timestamp: 1554642900000 }
+  str = prettifyTime({
+    log,
+    context: {
+      ...context,
+      translateTime: 'd mmm yyyy H:MM'
+    }
+  })
+  t.assert.strictEqual(str, '[7 Apr 2019 13:15]')
+
+  log = { time: '2019-04-07T09:15:00.000-04:00' }
+  str = prettifyTime({
+    log,
+    context: {
+      ...context,
+      translateTime: 'd mmm yyyy H:MM'
+    }
+  })
+  t.assert.strictEqual(str, '[7 Apr 2019 13:15]')
+
+  log = { timestamp: '2019-04-07T09:15:00.000-04:00' }
+  str = prettifyTime({
+    log,
+    context: {
+      ...context,
+      translateTime: 'd mmm yyyy H:MM'
+    }
+  })
+  t.assert.strictEqual(str, '[7 Apr 2019 13:15]')
+})
+
+test('passes through value', t => {
+  let log = { time: 1554642900000 }
+  let str = prettifyTime({
+    log,
+    context: {
+      ...context,
+      translateTime: undefined
+    }
+  })
+  t.assert.strictEqual(str, '[1554642900000]')
+
+  log = { timestamp: 1554642900000 }
+  str = prettifyTime({
+    log,
+    context: {
+      ...context,
+      translateTime: undefined
+    }
+  })
+  t.assert.strictEqual(str, '[1554642900000]')
+
+  log = { time: '2019-04-07T09:15:00.000-04:00' }
+  str = prettifyTime({
+    log,
+    context: {
+      ...context,
+      translateTime: undefined
+    }
+  })
+  t.assert.strictEqual(str, '[2019-04-07T09:15:00.000-04:00]')
+
+  log = { timestamp: '2019-04-07T09:15:00.000-04:00' }
+  str = prettifyTime({
+    log,
+    context: {
+      ...context,
+      translateTime: undefined
+    }
+  })
+  t.assert.strictEqual(str, '[2019-04-07T09:15:00.000-04:00]')
+})
+
+test('handles the 0 timestamp', t => {
+  let log = { time: 0 }
+  let str = prettifyTime({
+    log,
+    context: {
+      ...context,
+      translateTime: undefined
+    }
+  })
+  t.assert.strictEqual(str, '[0]')
+
+  log = { timestamp: 0 }
+  str = prettifyTime({
+    log,
+    context: {
+      ...context,
+      translateTime: undefined
+    }
+  })
+  t.assert.strictEqual(str, '[0]')
+})
+
+test('works with epoch as a number or string', (t) => {
+  t.plan(3)
+  const epoch = 1522431328992
+  const asNumber = prettifyTime({
+    log: { time: epoch, msg: 'foo' },
+    context: {
+      ...context,
+      translateTime: true
+    }
+  })
+  const asString = prettifyTime({
+    log: { time: `${epoch}`, msg: 'foo' },
+    context: {
+      ...context,
+      translateTime: true
+    }
+  })
+  const invalid = prettifyTime({
+    log: { time: '2 days ago', msg: 'foo' },
+    context: {
+      ...context,
+      translateTime: true
+    }
+  })
+  t.assert.strictEqual(asString, '[17:35:28.992]')
+  t.assert.strictEqual(asNumber, '[17:35:28.992]')
+  t.assert.strictEqual(invalid, '[2 days ago]')
+})
+
+test('strips unsafe control characters from default time output', t => {
+  const str = prettifyTime({
+    log: { time: 'invalid\u001B[2J\u009B[3J' },
+    context: {
+      ...context,
+      translateTime: true
+    }
+  })
+  t.assert.strictEqual(str, '[invalid[2J[3J]')
+})
+
+test('strips unsafe control characters after time values are coerced', t => {
+  const str = prettifyTime({
+    log: { time: ['invalid\u001B[2J'] },
+    context: {
+      ...context,
+      translateTime: false
+    }
+  })
+  t.assert.strictEqual(str, '[invalid[2J]')
+})
+
+test('uses custom prettifier', t => {
+  const str = prettifyTime({
+    log: { time: 0 },
+    context: {
+      ...context,
+      customPrettifiers: {
+        time () {
+          return 'done'
+        }
+      }
+    }
+  })
+  t.assert.strictEqual(str, 'done')
+})
+
+test('preserves control characters produced by a custom time prettifier', t => {
+  const str = prettifyTime({
+    log: { time: 0 },
+    context: {
+      ...context,
+      customPrettifiers: {
+        time () {
+          return '\u001B[31mdone\u001B[39m'
+        }
+      }
+    }
+  })
+  t.assert.strictEqual(str, '\u001B[31mdone\u001B[39m')
+})

package/node_modules/pino-pretty/lib/utils/split-property-key.js

@@ -0,0 +1,49 @@
+'use strict'
+
+module.exports = splitPropertyKey
+
+/**
+ * Splits the property key delimited by a dot character but not when it is preceded
+ * by a backslash.
+ *
+ * @param {string} key A string identifying the property.
+ *
+ * @returns {string[]} Returns a list of string containing each delimited property.
+ * e.g. `'prop2\.domain\.corp.prop2'` should return [ 'prop2.domain.com', 'prop2' ]
+ */
+function splitPropertyKey (key) {
+  const result = []
+  let backslash = false
+  let segment = ''
+
+  for (let i = 0; i < key.length; i++) {
+    const c = key.charAt(i)
+
+    if (c === '\\') {
+      backslash = true
+      continue
+    }
+
+    if (backslash) {
+      backslash = false
+      segment += c
+      continue
+    }
+
+    /* Non-escaped dot, push to result */
+    if (c === '.') {
+      result.push(segment)
+      segment = ''
+      continue
+    }
+
+    segment += c
+  }
+
+  /* Push last entry to result */
+  if (segment.length) {
+    result.push(segment)
+  }
+
+  return result
+}

package/node_modules/pino-pretty/lib/utils/split-property-key.test.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const { test } = require('node:test')
+const splitPropertyKey = require('./split-property-key')
+
+test('splitPropertyKey does not change key', t => {
+  const result = splitPropertyKey('data1')
+  t.assert.deepStrictEqual(result, ['data1'])
+})
+
+test('splitPropertyKey splits nested key', t => {
+  const result = splitPropertyKey('data1.data2.data-3')
+  t.assert.deepStrictEqual(result, ['data1', 'data2', 'data-3'])
+})
+
+test('splitPropertyKey splits nested keys ending with a dot', t => {
+  const result = splitPropertyKey('data1.data2.data-3.')
+  t.assert.deepStrictEqual(result, ['data1', 'data2', 'data-3'])
+})
+
+test('splitPropertyKey splits nested escaped key', t => {
+  const result = splitPropertyKey('logging\\.domain\\.corp/operation.foo.bar-2')
+  t.assert.deepStrictEqual(result, ['logging.domain.corp/operation', 'foo', 'bar-2'])
+})
+
+test('splitPropertyKey splits nested escaped key with special characters', t => {
+  const result = splitPropertyKey('logging\\.domain\\.corp/operation.!\t@#$%^&*()_+=-<>.bar\\.2')
+  t.assert.deepStrictEqual(result, ['logging.domain.corp/operation', '!\t@#$%^&*()_+=-<>', 'bar.2'])
+})

package/node_modules/pino-pretty/lib/utils/strip-unsafe-control-chars.js

@@ -0,0 +1,18 @@
+'use strict'
+
+module.exports = stripUnsafeControlChars
+
+// These control characters are the exact values this utility must remove.
+// eslint-disable-next-line no-control-regex
+const unsafeControlChars = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g
+
+/**
+ * Removes control characters that can alter terminal output while preserving
+ * tabs and newlines used for readable formatting.
+ *
+ * @param {*} input The value to sanitize.
+ * @returns {string} The sanitized string.
+ */
+function stripUnsafeControlChars (input) {
+  return String(input).replace(unsafeControlChars, '')
+}

package/node_modules/pino-pretty/lib/utils/strip-unsafe-control-chars.test.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const { test } = require('node:test')
+const stripUnsafeControlChars = require('./strip-unsafe-control-chars')
+
+test('coerces values before stripping unsafe control characters', t => {
+  const value = ['before\t\u001B[2J\nafter\u009B[3J']
+  t.assert.strictEqual(stripUnsafeControlChars(value), 'before\t[2J\nafter[3J')
+})

package/node_modules/pino-pretty/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "pino-pretty",
+  "version": "13.2.0",
+  "description": "Prettifier for Pino log lines",
+  "type": "commonjs",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "bin": {
+    "pino-pretty": "./bin.js"
+  },
+  "scripts": {
+    "ci": "eslint && borp --check-coverage && npm run test:types",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "test": "borp",
+    "test:types": "tstyche && attw --pack .",
+    "test:watch": "borp -w --reporter gh",
+    "test:report": "c8 --reporter html borp"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/pinojs/pino-pretty.git"
+  },
+  "keywords": [
+    "pino"
+  ],
+  "author": "James Sumners <james.sumners@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pinojs/pino-pretty/issues"
+  },
+  "homepage": "https://github.com/pinojs/pino-pretty#readme",
+  "dependencies": {
+    "colorette": "^2.0.7",
+    "dateformat": "^4.6.3",
+    "fast-copy": "^4.0.0",
+    "fast-safe-stringify": "^2.1.1",
+    "help-me": "^5.0.0",
+    "joycon": "^3.1.1",
+    "minimist": "^1.2.6",
+    "on-exit-leak-free": "^2.1.2",
+    "pino-abstract-transport": "^3.0.0",
+    "pump": "^3.0.3",
+    "secure-json-parse": "^4.1.0",
+    "sonic-boom": "^5.0.0",
+    "strip-json-comments": "^5.0.3"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.1",
+    "@jsumners/assert-match": "^1.0.0",
+    "@jsumners/line-reporter": "^1.0.1",
+    "@types/node": "^26.0.1",
+    "borp": "^1.0.0",
+    "eslint": "^9.39.1",
+    "fastbench": "^1.0.1",
+    "fastify-tsconfig": "^3.0.0",
+    "neostandard": "^0.13.0",
+    "pino": "^10.1.0",
+    "rimraf": "^6.1.2",
+    "semver": "^7.6.0",
+    "tstyche": "^7.1.0",
+    "typescript": "^6.0.2"
+  }
+}