@zuplo/cli 7.0.2 → 7.1.0

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const prettifyMetadata = require('./prettify-metadata')
 const getColorizer = require('../colors')
 const context = {
@@ -10,87 +10,87 @@ const context = {
   }
 }
 
-tap.test('returns `undefined` if no metadata present', async t => {
+test('returns `undefined` if no metadata present', t => {
   const str = prettifyMetadata({ log: {}, context })
-  t.equal(str, undefined)
+  t.assert.strictEqual(str, undefined)
 })
 
-tap.test('works with only `name` present', async t => {
+test('works with only `name` present', t => {
   const str = prettifyMetadata({ log: { name: 'foo' }, context })
-  t.equal(str, '(foo)')
+  t.assert.strictEqual(str, '(foo)')
 })
 
-tap.test('works with only `pid` present', async t => {
+test('works with only `pid` present', t => {
   const str = prettifyMetadata({ log: { pid: '1234' }, context })
-  t.equal(str, '(1234)')
+  t.assert.strictEqual(str, '(1234)')
 })
 
-tap.test('works with only `hostname` present', async t => {
+test('works with only `hostname` present', t => {
   const str = prettifyMetadata({ log: { hostname: 'bar' }, context })
-  t.equal(str, '(on bar)')
+  t.assert.strictEqual(str, '(on bar)')
 })
 
-tap.test('works with only `name` & `pid` present', async t => {
+test('works with only `name` & `pid` present', t => {
   const str = prettifyMetadata({ log: { name: 'foo', pid: '1234' }, context })
-  t.equal(str, '(foo/1234)')
+  t.assert.strictEqual(str, '(foo/1234)')
 })
 
-tap.test('works with only `name` & `hostname` present', async t => {
+test('works with only `name` & `hostname` present', t => {
   const str = prettifyMetadata({ log: { name: 'foo', hostname: 'bar' }, context })
-  t.equal(str, '(foo on bar)')
+  t.assert.strictEqual(str, '(foo on bar)')
 })
 
-tap.test('works with only `pid` & `hostname` present', async t => {
+test('works with only `pid` & `hostname` present', t => {
   const str = prettifyMetadata({ log: { pid: '1234', hostname: 'bar' }, context })
-  t.equal(str, '(1234 on bar)')
+  t.assert.strictEqual(str, '(1234 on bar)')
 })
 
-tap.test('works with only `name`, `pid`, & `hostname` present', async t => {
+test('works with only `name`, `pid`, & `hostname` present', t => {
   const str = prettifyMetadata({ log: { name: 'foo', pid: '1234', hostname: 'bar' }, context })
-  t.equal(str, '(foo/1234 on bar)')
+  t.assert.strictEqual(str, '(foo/1234 on bar)')
 })
 
-tap.test('works with only `name` & `caller` present', async t => {
+test('works with only `name` & `caller` present', t => {
   const str = prettifyMetadata({ log: { name: 'foo', caller: 'baz' }, context })
-  t.equal(str, '(foo) <baz>')
+  t.assert.strictEqual(str, '(foo) <baz>')
 })
 
-tap.test('works with only `pid` & `caller` present', async t => {
+test('works with only `pid` & `caller` present', t => {
   const str = prettifyMetadata({ log: { pid: '1234', caller: 'baz' }, context })
-  t.equal(str, '(1234) <baz>')
+  t.assert.strictEqual(str, '(1234) <baz>')
 })
 
-tap.test('works with only `hostname` & `caller` present', async t => {
+test('works with only `hostname` & `caller` present', t => {
   const str = prettifyMetadata({ log: { hostname: 'bar', caller: 'baz' }, context })
-  t.equal(str, '(on bar) <baz>')
+  t.assert.strictEqual(str, '(on bar) <baz>')
 })
 
-tap.test('works with only `name`, `pid`, & `caller` present', async t => {
+test('works with only `name`, `pid`, & `caller` present', t => {
   const str = prettifyMetadata({ log: { name: 'foo', pid: '1234', caller: 'baz' }, context })
-  t.equal(str, '(foo/1234) <baz>')
+  t.assert.strictEqual(str, '(foo/1234) <baz>')
 })
 
-tap.test('works with only `name`, `hostname`, & `caller` present', async t => {
+test('works with only `name`, `hostname`, & `caller` present', t => {
   const str = prettifyMetadata({ log: { name: 'foo', hostname: 'bar', caller: 'baz' }, context })
-  t.equal(str, '(foo on bar) <baz>')
+  t.assert.strictEqual(str, '(foo on bar) <baz>')
 })
 
-tap.test('works with only `caller` present', async t => {
+test('works with only `caller` present', t => {
   const str = prettifyMetadata({ log: { caller: 'baz' }, context })
-  t.equal(str, '<baz>')
+  t.assert.strictEqual(str, '<baz>')
 })
 
-tap.test('works with only `pid`, `hostname`, & `caller` present', async t => {
+test('works with only `pid`, `hostname`, & `caller` present', t => {
   const str = prettifyMetadata({ log: { pid: '1234', hostname: 'bar', caller: 'baz' }, context })
-  t.equal(str, '(1234 on bar) <baz>')
+  t.assert.strictEqual(str, '(1234 on bar) <baz>')
 })
 
-tap.test('works with all four present', async t => {
+test('works with all four present', t => {
   const str = prettifyMetadata({ log: { name: 'foo', pid: '1234', hostname: 'bar', caller: 'baz' }, context })
-  t.equal(str, '(foo/1234 on bar) <baz>')
+  t.assert.strictEqual(str, '(foo/1234 on bar) <baz>')
 })
 
-tap.test('uses prettifiers from passed prettifiers object', async t => {
+test('uses prettifiers from passed prettifiers object', t => {
   const prettifiers = {
     name (input) {
       return input.toUpperCase()
@@ -112,10 +112,10 @@ tap.test('uses prettifiers from passed prettifiers object', async t => {
       colorizer: { colors: {} }
     }
   })
-  t.equal(str, '(JOE/1234__ on BAR) <BAZ>')
+  t.assert.strictEqual(str, '(JOE/1234__ on BAR) <BAZ>')
 })
 
-tap.test('uses colorizer from passed context to colorize metadata', async t => {
+test('uses colorizer from passed context to colorize metadata', t => {
   const prettifiers = {
     name (input, _key, _log, { colors }) {
       return colors.blue(input)
@@ -145,5 +145,5 @@ tap.test('uses colorizer from passed context to colorize metadata', async t => {
   const colorizedCaller = colorizer.colors.cyan(log.caller)
   const expected = `(${colorizedName}/${colorizedPid} on ${colorizedHostname}) <${colorizedCaller}>`
 
-  t.equal(result, expected)
+  t.assert.strictEqual(result, expected)
 })

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

@@ -92,7 +92,7 @@ function prettifyObject ({
       lines = lines.replace(/\\\\/gi, '\\')
 
       const joinedLines = joinLinesWithIndentation({ input: lines, ident, eol })
-      result += `${ident}${keyName}:${joinedLines.startsWith(eol) ? '' : ' '}${joinedLines}${eol}`
+      result += `${ident}${objectColorizer.property(keyName)}:${joinedLines.startsWith(eol) ? '' : ' '}${joinedLines}${eol}`
     })
   }
 

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

@@ -1,12 +1,11 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const colors = require('../colors')
 const prettifyObject = require('./prettify-object')
 const {
   ERROR_LIKE_KEYS
 } = require('../constants')
-const getColorizer = require('../colors')
 
 const context = {
   EOL: '\n',
@@ -15,44 +14,44 @@ const context = {
   errorLikeObjectKeys: ERROR_LIKE_KEYS,
   objectColorizer: colors(),
   singleLine: false,
-  colorizer: getColorizer()
+  colorizer: colors()
 }
 
-tap.test('returns empty string if no properties present', async t => {
+test('returns empty string if no properties present', t => {
   const str = prettifyObject({ log: {}, context })
-  t.equal(str, '')
+  t.assert.strictEqual(str, '')
 })
 
-tap.test('works with single level properties', async t => {
+test('works with single level properties', t => {
   const str = prettifyObject({ log: { foo: 'bar' }, context })
-  t.equal(str, '    foo: "bar"\n')
+  t.assert.strictEqual(str, '    foo: "bar"\n')
 })
 
-tap.test('works with multiple level properties', async t => {
+test('works with multiple level properties', t => {
   const str = prettifyObject({ log: { foo: { bar: 'baz' } }, context })
-  t.equal(str, '    foo: {\n      "bar": "baz"\n    }\n')
+  t.assert.strictEqual(str, '    foo: {\n      "bar": "baz"\n    }\n')
 })
 
-tap.test('skips specified keys', async t => {
+test('skips specified keys', t => {
   const str = prettifyObject({
     log: { foo: 'bar', hello: 'world' },
     skipKeys: ['foo'],
     context
   })
-  t.equal(str, '    hello: "world"\n')
+  t.assert.strictEqual(str, '    hello: "world"\n')
 })
 
-tap.test('ignores predefined keys', async t => {
+test('ignores predefined keys', t => {
   const str = prettifyObject({ log: { foo: 'bar', pid: 12345 }, context })
-  t.equal(str, '    foo: "bar"\n')
+  t.assert.strictEqual(str, '    foo: "bar"\n')
 })
 
-tap.test('ignores escaped backslashes in string values', async t => {
+test('ignores escaped backslashes in string values', t => {
   const str = prettifyObject({ log: { foo_regexp: '\\[^\\w\\s]\\' }, context })
-  t.equal(str, '    foo_regexp: "\\[^\\w\\s]\\"\n')
+  t.assert.strictEqual(str, '    foo_regexp: "\\[^\\w\\s]\\"\n')
 })
 
-tap.test('ignores escaped backslashes in string values (singleLine option)', async t => {
+test('ignores escaped backslashes in string values (singleLine option)', t => {
   const str = prettifyObject({
     log: { foo_regexp: '\\[^\\w\\s]\\' },
     context: {
@@ -60,22 +59,22 @@ tap.test('ignores escaped backslashes in string values (singleLine option)', asy
       singleLine: true
     }
   })
-  t.equal(str, '{"foo_regexp":"\\[^\\w\\s]\\"}\n')
+  t.assert.strictEqual(str, '{"foo_regexp":"\\[^\\w\\s]\\"}\n')
 })
 
-tap.test('works with error props', async t => {
+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.ok(str.startsWith('    error:'))
-  t.ok(str.includes('     "message": "Something went wrong",'))
-  t.ok(str.includes('         Error: Something went wrong'))
+  t.assert.ok(str.startsWith('    error:'))
+  t.assert.ok(str.includes('     "message": "Something went wrong",'))
+  t.assert.ok(str.includes('         Error: Something went wrong'))
 })
 
-tap.test('customPrettifiers gets applied', async t => {
+test('customPrettifiers gets applied', t => {
   const customPrettifiers = {
     foo: v => v.toUpperCase()
   }
@@ -86,10 +85,10 @@ tap.test('customPrettifiers gets applied', async t => {
       customPrettifiers
     }
   })
-  t.equal(str.startsWith('    foo: FOO'), true)
+  t.assert.strictEqual(str.startsWith('    foo: FOO'), true)
 })
 
-tap.test('skips lines omitted by customPrettifiers', async t => {
+test('skips lines omitted by customPrettifiers', t => {
   const customPrettifiers = {
     foo: () => { return undefined }
   }
@@ -100,11 +99,11 @@ tap.test('skips lines omitted by customPrettifiers', async t => {
       customPrettifiers
     }
   })
-  t.equal(str.includes('bar: "bar"'), true)
-  t.equal(str.includes('foo: "foo"'), false)
+  t.assert.strictEqual(str.includes('bar: "bar"'), true)
+  t.assert.strictEqual(str.includes('foo: "foo"'), false)
 })
 
-tap.test('joined lines omits starting eol', async t => {
+test('joined lines omits starting eol', t => {
   const str = prettifyObject({
     log: { msg: 'doing work', calls: ['step 1', 'step 2', 'step 3'], level: 30 },
     context: {
@@ -115,7 +114,7 @@ tap.test('joined lines omits starting eol', async t => {
       }
     }
   })
-  t.equal(str, [
+  t.assert.strictEqual(str, [
     'msg: "doing work"',
     'calls:',
     '  step 1',
@@ -125,7 +124,7 @@ tap.test('joined lines omits starting eol', async t => {
   ].join('\n'))
 })
 
-tap.test('errors skips prettifiers', async t => {
+test('errors skips prettifiers', t => {
   const customPrettifiers = {
     err: () => { return 'is_err' }
   }
@@ -136,10 +135,10 @@ tap.test('errors skips prettifiers', async t => {
       customPrettifiers
     }
   })
-  t.equal(str.includes('err: is_err'), true)
+  t.assert.strictEqual(str.includes('err: is_err'), true)
 })
 
-tap.test('errors skips prettifying if no lines are present', async t => {
+test('errors skips prettifying if no lines are present', t => {
   const customPrettifiers = {
     err: () => { return undefined }
   }
@@ -150,5 +149,45 @@ tap.test('errors skips prettifying if no lines are present', async t => {
       customPrettifiers
     }
   })
-  t.equal(str, '')
+  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.test.js

@@ -2,7 +2,7 @@
 
 process.env.TZ = 'UTC'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const prettifyTime = require('./prettify-time')
 const {
   TIMESTAMP_KEY
@@ -13,12 +13,12 @@ const context = {
   customPrettifiers: {}
 }
 
-tap.test('returns `undefined` if `time` or `timestamp` not in log', async t => {
+test('returns `undefined` if `time` or `timestamp` not in log', t => {
   const str = prettifyTime({ log: {}, context })
-  t.equal(str, undefined)
+  t.assert.strictEqual(str, undefined)
 })
 
-tap.test('returns prettified formatted time from custom field', async t => {
+test('returns prettified formatted time from custom field', t => {
   const log = { customtime: 1554642900000 }
   let str = prettifyTime({
     log,
@@ -27,7 +27,7 @@ tap.test('returns prettified formatted time from custom field', async t => {
       timestampKey: 'customtime'
     }
   })
-  t.equal(str, '[13:15:00.000]')
+  t.assert.strictEqual(str, '[13:15:00.000]')
 
   str = prettifyTime({
     log,
@@ -37,10 +37,10 @@ tap.test('returns prettified formatted time from custom field', async t => {
       timestampKey: 'customtime'
     }
   })
-  t.equal(str, '[1554642900000]')
+  t.assert.strictEqual(str, '[1554642900000]')
 })
 
-tap.test('returns prettified formatted time', async t => {
+test('returns prettified formatted time', t => {
   let log = { time: 1554642900000 }
   let str = prettifyTime({
     log,
@@ -48,7 +48,7 @@ tap.test('returns prettified formatted time', async t => {
       ...context
     }
   })
-  t.equal(str, '[13:15:00.000]')
+  t.assert.strictEqual(str, '[13:15:00.000]')
 
   log = { timestamp: 1554642900000 }
   str = prettifyTime({
@@ -57,7 +57,7 @@ tap.test('returns prettified formatted time', async t => {
       ...context
     }
   })
-  t.equal(str, '[13:15:00.000]')
+  t.assert.strictEqual(str, '[13:15:00.000]')
 
   log = { time: '2019-04-07T09:15:00.000-04:00' }
   str = prettifyTime({
@@ -66,7 +66,7 @@ tap.test('returns prettified formatted time', async t => {
       ...context
     }
   })
-  t.equal(str, '[13:15:00.000]')
+  t.assert.strictEqual(str, '[13:15:00.000]')
 
   log = { timestamp: '2019-04-07T09:15:00.000-04:00' }
   str = prettifyTime({
@@ -75,7 +75,7 @@ tap.test('returns prettified formatted time', async t => {
       ...context
     }
   })
-  t.equal(str, '[13:15:00.000]')
+  t.assert.strictEqual(str, '[13:15:00.000]')
 
   log = { time: 1554642900000 }
   str = prettifyTime({
@@ -85,7 +85,7 @@ tap.test('returns prettified formatted time', async t => {
       translateTime: 'd mmm yyyy H:MM'
     }
   })
-  t.equal(str, '[7 Apr 2019 13:15]')
+  t.assert.strictEqual(str, '[7 Apr 2019 13:15]')
 
   log = { timestamp: 1554642900000 }
   str = prettifyTime({
@@ -95,7 +95,7 @@ tap.test('returns prettified formatted time', async t => {
       translateTime: 'd mmm yyyy H:MM'
     }
   })
-  t.equal(str, '[7 Apr 2019 13:15]')
+  t.assert.strictEqual(str, '[7 Apr 2019 13:15]')
 
   log = { time: '2019-04-07T09:15:00.000-04:00' }
   str = prettifyTime({
@@ -105,7 +105,7 @@ tap.test('returns prettified formatted time', async t => {
       translateTime: 'd mmm yyyy H:MM'
     }
   })
-  t.equal(str, '[7 Apr 2019 13:15]')
+  t.assert.strictEqual(str, '[7 Apr 2019 13:15]')
 
   log = { timestamp: '2019-04-07T09:15:00.000-04:00' }
   str = prettifyTime({
@@ -115,10 +115,10 @@ tap.test('returns prettified formatted time', async t => {
       translateTime: 'd mmm yyyy H:MM'
     }
   })
-  t.equal(str, '[7 Apr 2019 13:15]')
+  t.assert.strictEqual(str, '[7 Apr 2019 13:15]')
 })
 
-tap.test('passes through value', async t => {
+test('passes through value', t => {
   let log = { time: 1554642900000 }
   let str = prettifyTime({
     log,
@@ -127,7 +127,7 @@ tap.test('passes through value', async t => {
       translateTime: undefined
     }
   })
-  t.equal(str, '[1554642900000]')
+  t.assert.strictEqual(str, '[1554642900000]')
 
   log = { timestamp: 1554642900000 }
   str = prettifyTime({
@@ -137,7 +137,7 @@ tap.test('passes through value', async t => {
       translateTime: undefined
     }
   })
-  t.equal(str, '[1554642900000]')
+  t.assert.strictEqual(str, '[1554642900000]')
 
   log = { time: '2019-04-07T09:15:00.000-04:00' }
   str = prettifyTime({
@@ -147,7 +147,7 @@ tap.test('passes through value', async t => {
       translateTime: undefined
     }
   })
-  t.equal(str, '[2019-04-07T09:15:00.000-04:00]')
+  t.assert.strictEqual(str, '[2019-04-07T09:15:00.000-04:00]')
 
   log = { timestamp: '2019-04-07T09:15:00.000-04:00' }
   str = prettifyTime({
@@ -157,10 +157,10 @@ tap.test('passes through value', async t => {
       translateTime: undefined
     }
   })
-  t.equal(str, '[2019-04-07T09:15:00.000-04:00]')
+  t.assert.strictEqual(str, '[2019-04-07T09:15:00.000-04:00]')
 })
 
-tap.test('handles the 0 timestamp', async t => {
+test('handles the 0 timestamp', t => {
   let log = { time: 0 }
   let str = prettifyTime({
     log,
@@ -169,7 +169,7 @@ tap.test('handles the 0 timestamp', async t => {
       translateTime: undefined
     }
   })
-  t.equal(str, '[0]')
+  t.assert.strictEqual(str, '[0]')
 
   log = { timestamp: 0 }
   str = prettifyTime({
@@ -179,10 +179,10 @@ tap.test('handles the 0 timestamp', async t => {
       translateTime: undefined
     }
   })
-  t.equal(str, '[0]')
+  t.assert.strictEqual(str, '[0]')
 })
 
-tap.test('works with epoch as a number or string', (t) => {
+test('works with epoch as a number or string', (t) => {
   t.plan(3)
   const epoch = 1522431328992
   const asNumber = prettifyTime({
@@ -206,12 +206,12 @@ tap.test('works with epoch as a number or string', (t) => {
       translateTime: true
     }
   })
-  t.same(asString, '[17:35:28.992]')
-  t.same(asNumber, '[17:35:28.992]')
-  t.same(invalid, '[2 days ago]')
+  t.assert.strictEqual(asString, '[17:35:28.992]')
+  t.assert.strictEqual(asNumber, '[17:35:28.992]')
+  t.assert.strictEqual(invalid, '[2 days ago]')
 })
 
-tap.test('uses custom prettifier', async t => {
+test('uses custom prettifier', t => {
   const str = prettifyTime({
     log: { time: 0 },
     context: {
@@ -223,5 +223,5 @@ tap.test('uses custom prettifier', async t => {
       }
     }
   })
-  t.equal(str, 'done')
+  t.assert.strictEqual(str, 'done')
 })

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

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