chore: migrate to node compat ts

Author: spence-s

cli.ts

@@ -5,8 +5,8 @@ import os from 'node:os';
 import pump from 'pump';
 import {cosmiconfigSync} from 'cosmiconfig';
 import meow from 'meow';
-import type {PrettifyOptions} from './lib/utils/types.js';
-import {build} from './index.js';
+import type {PrettifyOptions} from './lib/utils/types.ts';
+import {build} from './index.ts';
 
 const cli = meow(
   `

index.ts

@@ -2,9 +2,9 @@ import {Transform} from 'node:stream';
 import pump from 'pump';
 import abstractTransport, {type OnUnknown} from 'pino-abstract-transport';
 import type {SonicBoom, SonicBoomOpts} from 'sonic-boom';
-import prettify from './lib/prettify.js';
-import buildSafeSonicBoom from './lib/build-safe-sonic-boom.js';
-import type {PrettifyOptions} from './lib/utils/types.js';
+import prettify from './lib/prettify.ts';
+import buildSafeSonicBoom from './lib/build-safe-sonic-boom.ts';
+import type {PrettifyOptions} from './lib/utils/types.ts';
 
 function build(
   options: PrettifyOptions &

lib/formatters.ts

@@ -11,8 +11,8 @@ import pcStringify from 'json-stringify-pretty-compact';
 import {format} from 'date-fns';
 import getValue from 'get-value';
 import isUnicodeSupported from 'is-unicode-supported';
-import type {NumLevels, Levels, Colors} from './utils/types.js';
-import isObject from './utils/is-object.js';
+import type {NumLevels, Levels, Colors} from './utils/types.ts';
+import isObject from './utils/is-object.ts';
 
 const nl = '\n';
 
@@ -21,10 +21,9 @@ const defaultTimeFormat = 'h:mm:ss.SSS aaa';
 /** key map cache - assigned once at startup if user has custom keymap */
 const highlight = _highlight.default;
 
-const colorMap: Record<Levels | 'userlvl', Colors> = {
+const colorMap: Record<Levels, Colors> = {
   warn: 'yellow',
   info: 'cyan',
-  userlvl: 'cyan',
   error: 'red',
   debug: 'blue',
   trace: 'white',

lib/prettify.ts

@@ -2,8 +2,8 @@
 
 import {logLineFactory} from 'json-log-line';
 import _highlight from 'cli-highlight';
-import type {PrettifyOptions} from './utils/types.js';
-import {Formatter} from './formatters.js';
+import type {PrettifyOptions} from './utils/types.ts';
+import {Formatter} from './formatters.ts';
 
 const defaultTimeFormat = 'h:mm:ss.SSS aaa';
 

lib/utils/convert-log-number.ts

@@ -1,4 +1,4 @@
-import type {Levels} from './types.js';
+import type {Levels} from './types.ts';
 
 function convertLogNumber(level: number): Levels | 'userlvl' {
   if (level === 10) return 'trace';

lib/utils/is-empty.ts

@@ -1,11 +1,11 @@
-import isObject from './is-object.js';
+import isObject from './is-object.ts';
 
 function isEmpty(object: unknown): boolean {
   return Boolean(
     isObject(object) &&
-      (object === undefined ||
-        object === null ||
-        Object.keys(object).length === 0),
+    (object === undefined ||
+      object === null ||
+      Object.keys(object).length === 0),
   );
 }
 

package.json

@@ -53,6 +53,8 @@
     "prepare": "husky",
     "release": "np",
     "test": "npm run build:test && c8 ava",
+    "test:all": "npm run test && npm run test:node",
+    "test:node": "npm run build:test && node --test --test-update-snapshots test-node/**/*.test.ts",
     "test:watch": "ava --watch",
     "update": "ncu -i"
   },

test-node/cli.test.ts

@@ -0,0 +1,158 @@
+/* eslint-disable @typescript-eslint/no-floating-promises */
+import {test, type TestContext} from 'node:test';
+import {format} from 'date-fns';
+import {execa} from 'execa';
+import {err} from 'pino-std-serializers';
+
+test('cli --help runs without error', async (t: TestContext) => {
+  const {stdout} = await execa('node', ['dist/cli.js', '--help']);
+  t.assert.snapshot(stdout);
+});
+
+test('cli formats a log line', async (t: TestContext) => {
+  const {stdout} = await execa('node', ['dist/cli.js', '--colors=false'], {
+    input: JSON.stringify({
+      level: 30,
+      msg: 'hello',
+      time: Date.now(),
+    }),
+  });
+  console.log(stdout);
+  t.assert.ok(stdout.includes('INFO  hello'));
+});
+
+test('cli respects --messageKey option', async (t: TestContext) => {
+  const time = Date.now();
+  // Test with default messageKey
+  const {stdout: stdoutWithDefaultMessageKey} = await execa(
+    'node',
+    ['dist/cli.js'],
+    {
+      input: JSON.stringify({
+        level: 30,
+        msg: 'hello',
+        time,
+      }),
+    },
+  );
+
+  const {stdout} = await execa(
+    'node',
+    ['dist/cli.js', '--messageKey=message'],
+    {
+      input: JSON.stringify({
+        level: 30,
+        message: 'hello',
+        time,
+      }),
+    },
+  );
+
+  t.assert.ok(stdoutWithDefaultMessageKey.includes('INFO  hello'));
+  t.assert.ok(stdout.includes('INFO  hello'));
+  t.assert.strictEqual(stdoutWithDefaultMessageKey, stdout);
+});
+
+test('cli respects --errorKey option', async (t: TestContext) => {
+  const serializedError = err(new Error('test error'));
+  const time = Date.now();
+
+  const {stdout: stdoutWithDefaultErrorKey} = await execa(
+    'node',
+    ['dist/cli.js'],
+    {
+      input: JSON.stringify({
+        level: 50,
+        err: serializedError,
+        time,
+      }),
+    },
+  );
+
+  const {stdout: stdOutWithErrorKeyOption} = await execa(
+    'node',
+    ['dist/cli.js', '--errorKey=error'],
+    {
+      input: JSON.stringify({
+        level: 50,
+        error: serializedError,
+        time,
+      }),
+    },
+  );
+  t.assert.strictEqual(stdoutWithDefaultErrorKey, stdOutWithErrorKeyOption);
+});
+
+test('cli respects --timeKey option', async (t: TestContext) => {
+  const time = Date.now();
+
+  const {stdout: stdOutWithDefaultTimeKey} = await execa(
+    'node',
+    ['dist/cli.js'],
+    {
+      input: JSON.stringify({
+        level: 30,
+        time,
+      }),
+    },
+  );
+
+  const {stdout: stdoutWithTimeKeyOption} = await execa(
+    'node',
+    ['dist/cli.js', '--timeKey=timestamp'],
+    {
+      input: JSON.stringify({
+        level: 30,
+        timestamp: time,
+      }),
+    },
+  );
+  t.assert.strictEqual(stdoutWithTimeKeyOption, stdOutWithDefaultTimeKey);
+});
+
+// test cli timeformat option
+test('cli respects --timeFormat option', async (t: TestContext) => {
+  const time = Date.now();
+  const {stdout} = await execa(
+    'node',
+    ['dist/cli.js', '--timeFormat=yyyy-MM-dd HH:mm:ss'],
+    {
+      input: JSON.stringify({
+        level: 30,
+        msg: 'hello',
+        time,
+      }),
+    },
+  );
+
+  // Check if the output contains the formatted time
+  t.assert.ok(stdout.includes(format(time, 'yyyy-MM-dd HH:mm:ss')));
+});
+
+// test cli singleLine option
+test('cli respects --singleLine option', async (t: TestContext) => {
+  const input = JSON.stringify({
+    level: 30,
+    msg: 'hello',
+    time: Date.now(),
+    extra: {
+      field1: 'value1',
+      field2: 'value2',
+      field3: 'value3',
+      field4: 'value4',
+      field5: 'value5',
+    },
+  });
+
+  const {stdout: stdoutMultiline} = await execa('node', ['dist/cli.js'], {
+    input,
+  });
+
+  const {stdout} = await execa('node', ['dist/cli.js', '--singleLine'], {
+    input,
+  });
+
+  t.assert.ok(stdoutMultiline.includes('\n'));
+  // Check if the output is a single line
+  t.assert.ok(!stdout.includes('\n'));
+});

test-node/cli.test.ts.snapshot

@@ -0,0 +1,3 @@
+exports[`cli --help runs without error 1`] = `
+"\\n  Prettiest Pino Prettifier in all the land\\n\\n  Usage\\n    $ node my-app-with-pino-logging | pino-princess\\n\\n  Options\\n    --exclude, -e    excluded log fields separated by comma. Is overriden by included fields.\\n    --include, -i    included log fields separated by comma. Overrides excluded fields.\\n    --messageKey     key for the message field, defaults to 'msg'\\n    --errorKey       key for the error field, defaults to 'err'\\n    --timeKey        key for the time field, defaults to 'time'\\n    --timeFormat     format for the time field, passed to date-fns format defaults to 'h:mm:ss.SSS aaa'\\n    --singleLine     format the output as a single line, defaults to false\\n    --unicode        force unicode emojis on or off, auto-detected by default\\n    --no-colors      disable all color output, auto-detected by default\\n  \\n"
+`;

test-node/formatters.test.ts

@@ -0,0 +1,146 @@
+/* eslint-disable @typescript-eslint/no-floating-promises */
+import {test, before} from 'node:test';
+import assert from 'node:assert';
+import {Formatter} from '../lib/formatters.ts';
+
+let stripAnsi: (str: string) => string;
+
+before(async () => {
+  const {default: stripAnsiModule} = await import('strip-ansi');
+  stripAnsi = stripAnsiModule;
+});
+
+const {
+  formatLevel,
+  formatLoadTime,
+  formatName,
+  formatMessage,
+  formatExtraFields,
+  formatMethod,
+  formatStack,
+  formatUrl,
+  formatStatusCode,
+  formatErrorProp,
+  formatId,
+} = new Formatter({
+  keyMap: {},
+  supportsColor: true,
+  supportsUnicode: true,
+});
+
+test('formatLevel', () => {
+  /**
+   * note: the space after some of the levels is intentional
+   * as it is part of the formatLevel function, which pads the shorter strings
+   */
+
+  const info = stripAnsi(formatLevel(30));
+  assert.strictEqual(info, '✨ INFO ');
+
+  const warn = stripAnsi(formatLevel(40));
+  assert.strictEqual(warn, '⚠️  WARN ');
+
+  const error = stripAnsi(formatLevel(50));
+  assert.strictEqual(error, '🚨 ERROR');
+
+  const fatal = stripAnsi(formatLevel(60));
+  assert.strictEqual(fatal, '💀 FATAL');
+
+  // const userlvl = stripAnsi(formatLevel(0));
+  // assert.strictEqual(userlvl, '👤 USERLVL');
+
+  const debug = stripAnsi(formatLevel(20));
+  assert.strictEqual(debug, '🐛 DEBUG');
+});
+
+test('formatLoadTime', () => {
+  const loadTime1 = stripAnsi(formatLoadTime('0.1') ?? '');
+  assert.strictEqual(loadTime1, '0ms');
+
+  const loadTime2 = stripAnsi(formatLoadTime('100') ?? '');
+  assert.strictEqual(loadTime2, '100ms');
+
+  const loadTime3 = stripAnsi(formatLoadTime(500) ?? '');
+  assert.strictEqual(loadTime3, '500ms');
+});
+
+test('formatName', () => {
+  const name1 = stripAnsi(formatName('name') ?? '');
+  assert.strictEqual(name1, '[name]');
+});
+
+test('formatMessage', () => {
+  const messageInfo = stripAnsi(formatMessage('message', {level: 30}) ?? '');
+  assert.strictEqual(messageInfo, 'message');
+
+  const messageWarn = stripAnsi(formatMessage('message', {level: 40}) ?? '');
+  assert.strictEqual(messageWarn, 'message');
+
+  const messageError = stripAnsi(formatMessage('message', {level: 50}) ?? '');
+  assert.strictEqual(messageError, 'message');
+
+  const messageFatal = stripAnsi(formatMessage('message', {level: 60}) ?? '');
+  assert.strictEqual(messageFatal, 'message');
+
+  const messageUserlvl = stripAnsi(formatMessage('message', {level: 30}) ?? '');
+
+  assert.strictEqual(messageUserlvl, 'message');
+
+  const messageDebug = stripAnsi(formatMessage('message', {level: 20}) ?? '');
+  assert.strictEqual(messageDebug, 'message');
+});
+
+test('formatExtraFields', () => {
+  const extraFields = stripAnsi(
+    formatExtraFields({
+      extra: 'fields',
+    }) ?? '',
+  );
+  assert.strictEqual(extraFields, '\n  "extra": "fields"');
+});
+
+test('formatMethod', () => {
+  const method = stripAnsi(formatMethod('method') ?? '');
+  assert.strictEqual(method, 'METHOD');
+});
+
+test('formatStack', () => {
+  const stackFormatted = stripAnsi(formatStack('stack') ?? '');
+  assert.strictEqual(stackFormatted, '\n  stack');
+});
+
+test('formatUrl', () => {
+  const url = stripAnsi(formatUrl('url') ?? '');
+  assert.strictEqual(url, '    url');
+
+  // with status code
+  const urlWithStatusCode = stripAnsi(
+    formatUrl('url', {res: {statusCode: 200}}) ?? '',
+  );
+
+  assert.strictEqual(urlWithStatusCode, 'url');
+});
+
+test('formatStatusCode', () => {
+  const statusCode = stripAnsi(formatStatusCode(200) ?? '');
+  assert.strictEqual(statusCode, '200');
+});
+
+test('formatId', () => {
+  const statusCode = stripAnsi(formatId('12345') ?? '');
+  assert.strictEqual(statusCode, '[ID:12345]');
+});
+
+test('formatErrorProp > basic error', () => {
+  const error = new Error('test error');
+
+  const errorProp = stripAnsi(
+    formatErrorProp({
+      type: 'Error',
+      message: 'test error',
+      stack: error.stack,
+    }) ?? '',
+  );
+
+  assert.strictEqual(errorProp, `\n  ${error.stack ?? ''}\n`);
+});