@brianbuie/node-kit 0.15.1 → 0.16.0

package/src/Log.ts

@@ -1,126 +1,86 @@
-import { inspect } from 'node:util';
-import { isObjectLike } from 'lodash-es';
-import chalk, { type ChalkInstance } from 'chalk';
-import { snapshot } from './snapshot.ts';
-import { Format } from './Format.ts';
+import { merge } from 'lodash-es';
+import { default as pino, type Logger } from 'pino';
 
-// https://docs.cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#logseverity
-type Severity = 'DEFAULT' | 'DEBUG' | 'INFO' | 'NOTICE' | 'WARNING' | 'ERROR' | 'CRITICAL' | 'ALERT' | 'EMERGENCY';
+export type LogDetails = Record<string, unknown>;
 
-type Options = {
-  severity: Severity;
-  color: ChalkInstance;
-};
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
 
-type Entry = {
-  message?: string;
-  severity: Severity;
-  stack?: string;
-  details?: unknown[];
+export type LogOptions = pino.LoggerOptions & {
+  environment?: string;
 };
 
+/**
+ * Wrapper for [pino](https://github.com/pinojs/pino)
+ * Levels: fatal, error, warn, info, debug, trace
+ * Use `LOG_LEVL=info` to limit what's printed to console
+ * Use `Log.configure` to customize the pino instance
+ */
 export class Log {
-  static getStack() {
-    const details = { stack: '' };
-    // replaces details.stack with current stack trace, excluding this Log.getStack call
-    Error.captureStackTrace(details, Log.getStack);
-    // remove 'Error' on first line
-    return details.stack
-      .split('\n')
-      .map(l => l.trim())
-      .filter(l => l !== 'Error');
-  }
+  static #logger?: Logger;
+  static #options: LogOptions;
 
-  /**
-   * Gcloud parses JSON in stdout
-   */
-  static #toGcloud(entry: Entry) {
-    const details = entry.details?.length === 1 ? entry.details[0] : entry.details;
-    const output = { ...entry, details, stack: entry.stack || this.getStack() };
-    console.log(JSON.stringify(snapshot(output)));
+  static createLogger(): Logger {
+    const isProduction = this.#options?.environment === 'production' || process.env.NODE_ENV === 'production';
+    const defaultOptions: LogOptions = {
+      level: process.env.LOG_LEVEL ?? (isProduction ? 'info' : 'debug'),
+      timestamp: pino.stdTimeFunctions.isoTime,
+      formatters: {
+        level(label: string) {
+          return { level: label };
+        },
+      },
+      transport: isProduction
+        ? undefined
+        : {
+            target: 'pino-pretty',
+            options: {
+              colorize: true,
+              singleLine: true,
+              ignore: 'pid,hostname',
+            },
+          },
+    };
+    return pino(merge(defaultOptions, this.#options));
   }
 
-  /**
-   * Includes colors and better inspection for logging during dev
-   */
-  static #toConsole(entry: Entry, color: ChalkInstance) {
-    if (entry.message) console.log(color(`${Format.date('h:m:s')} [${entry.severity}] ${entry.message}`));
-    entry.details?.forEach(detail => {
-      console.log(inspect(detail, { depth: 10, breakLength: 100, compact: true, colors: true }));
-    });
+  static configure(options: LogOptions = {}): void {
+    this.#options = options;
+    this.#logger = this.createLogger();
   }
 
-  static #log({ severity, color }: Options, ...input: unknown[]) {
-    const { message, details } = this.prepare(...input);
-    const entry: Entry = { message, severity, details };
-    // https://cloud.google.com/run/docs/container-contract#env-vars
-    const isGcloud = process.env.K_SERVICE !== undefined || process.env.CLOUD_RUN_JOB !== undefined;
-    if (isGcloud) {
-      this.#toGcloud(entry);
-    } else {
-      this.#toConsole(entry, color);
-    }
-    return entry;
+  static #getLogger(): Logger {
+    return (this.#logger ??= this.createLogger());
   }
 
-  /**
-   * Handle first argument being a string or an object with a 'message' prop
-   */
-  static prepare(...input: unknown[]): { message?: string; details: unknown[] } {
-    let [firstArg, ...rest] = input;
-    // First argument is a string, use that as the message
-    if (typeof firstArg === 'string') {
-      return { message: firstArg, details: rest };
-    }
-    // First argument is an object with a `message` property
-    // @ts-ignore
-    if (isObjectLike(firstArg) && typeof firstArg['message'] === 'string') {
-      const { message, ...firstDetails } = firstArg as { message: string };
-      return { message, details: [firstDetails, ...rest] };
+  static #write(level: LogLevel, message: string, details?: LogDetails): void {
+    if (details === undefined) {
+      Log.#getLogger()[level](message);
+    } else {
+      Log.#getLogger()[level](details, message);
     }
-    // No message found, log all args as details
-    return { details: input };
   }
 
-  /**
-   * Events that require action or attention immediately
-   */
-  static alert(...input: unknown[]) {
-    return this.#log({ severity: 'ALERT', color: chalk.bgRed }, ...input);
+  static trace(message: string, details?: LogDetails): void {
+    Log.#write('trace', message, details);
   }
 
-  /**
-   * Events that cause problems
-   */
-  static error(...input: unknown[]) {
-    return this.#log({ severity: 'ERROR', color: chalk.red }, ...input);
+  static debug(message: string, details?: LogDetails): void {
+    Log.#write('debug', message, details);
   }
 
-  /**
-   * Events that might cause problems
-   */
-  static warn(...input: unknown[]) {
-    return this.#log({ severity: 'WARNING', color: chalk.yellow }, ...input);
+  static info(message: string, details?: LogDetails): void {
+    Log.#write('info', message, details);
   }
 
-  /**
-   * Normal but significant events, such as start up, shut down, or a configuration change
-   */
-  static notice(...input: unknown[]) {
-    return this.#log({ severity: 'NOTICE', color: chalk.cyan }, ...input);
+  static warn(message: string, details?: LogDetails): void {
+    Log.#write('warn', message, details);
   }
 
-  /**
-   * Routine information, such as ongoing status or performance
-   */
-  static info(...input: unknown[]) {
-    return this.#log({ severity: 'INFO', color: chalk.white }, ...input);
+  static error(message: string, details?: LogDetails): void {
+    Log.#write('error', message, details);
   }
 
-  /**
-   * Debug or trace information
-   */
-  static debug(...input: unknown[]) {
-    return this.#log({ severity: 'DEBUG', color: chalk.gray }, ...input);
+  static fatal(message: string, details?: LogDetails): void {
+    Log.#write('fatal', message, details);
   }
 }

package/src/TypeWriter.ts

@@ -2,12 +2,20 @@ import * as fs from 'node:fs';
 import { merge } from 'lodash-es';
 import * as qt from 'quicktype-core';
 
+/**
+ * Wrapper for [quicktype-core](https://github.com/glideapps/quicktype)
+ * @example
+ * const group = new TypeWriter('Group');
+ * await types.addMember('Thing', [{ a: 1 }, { a: 2, b: 1 }]);
+ * await types.toFile();
+ * // type def for `Thing` saved in `types/Group.types.ts`
+ */
 export class TypeWriter {
-  moduleName;
+  moduleName: string;
   input = qt.jsonInputForTargetLanguage('typescript');
-  outDir;
-  outFile;
-  qtSettings;
+  outDir: string;
+  outFile: string;
+  qtSettings: Partial<qt.Options>;
 
   constructor(moduleName: string, settings: { outDir?: string; outFile?: string } & Partial<qt.Options> = {}) {
     this.moduleName = moduleName;
@@ -26,12 +34,12 @@ export class TypeWriter {
     this.qtSettings = merge(defaultSettings, qtSettings);
   }
 
-  async addMember(name: string, _samples: any[]) {
+  async addMember(name: string, _samples: any[]): Promise<void> {
     const samples = _samples.map(s => (typeof s === 'string' ? s : JSON.stringify(s)));
     await this.input.addSource({ name, samples });
   }
 
-  async toString() {
+  async toString(): Promise<string> {
     const inputData = new qt.InputData();
     inputData.addInput(this.input);
     const result = await qt.quicktype({
@@ -41,7 +49,7 @@ export class TypeWriter {
     return result.lines.join('\n');
   }
 
-  async toFile() {
+  async toFile(): Promise<void> {
     const result = await this.toString();
     fs.mkdirSync(this.outDir, { recursive: true });
     fs.writeFileSync(`${this.outDir}/${this.outFile}`, result);

package/src/snapshot.ts

@@ -1,8 +1,9 @@
 import { isObjectLike } from 'lodash-es';
 
 /**
- * Allows special objects (Error, Headers, Set) to be included in JSON.stringify output.
- * Functions are removed
+ * @deprecated
+ * Allows special objects (Error, Headers, Set) to be included in JSON.stringify output. Functions are removed.
+ * ⚠️ This is bad! Only use it for debugging!
  */
 export function snapshot(i: unknown, max = 50, depth = 0): any {
   if (Array.isArray(i)) {

package/src/timeout.ts

@@ -1,4 +1,4 @@
-export async function timeout(ms: number) {
+export async function timeout(ms: number): Promise<void> {
   return new Promise(resolve => {
     setTimeout(resolve, ms);
   });