@vvlad1973/simple-logger 2.1.9 → 2.2.0

package/src/classes/simple-logger.ts

@@ -13,13 +13,12 @@ import {
   prepareLogCall,
 } from '../helpers/helpers.js';
 import { LoggerLevels } from '../constants/constants.js';
-import {
-  type ExternalLogger,
-  type LogFn,
-  type LoggerFactory,
-  type LoggerLevel,
-  type LoggerOptions,
-  PreparedLogCall,
+import type {
+  ExternalLogger,
+  LogFn,
+  LoggerFactory,
+  LoggerLevel,
+  LoggerOptions,
 } from '../types/simple-logger.types.js';
 
 export default class SimpleLogger {
@@ -69,13 +68,13 @@ export default class SimpleLogger {
     const levels = Object.values(LoggerLevels);
     if (explicitLevel) return explicitLevel;
     if (
-      logger &&
-      typeof logger === 'object' &&
       'level' in logger &&
-      typeof (logger as any).level === 'string'
+      typeof logger.level === 'string'
     ) {
-      const lvl = (logger as any).level.toLowerCase();
-      if (levels.includes(lvl as LoggerLevel)) return lvl as LoggerLevel;
+      const lvl = logger.level.toLowerCase();
+      const isValidLevel = (value: string): value is LoggerLevel =>
+        (levels as readonly string[]).includes(value);
+      if (isValidLevel(lvl)) return lvl;
     }
     return levels[this.currentLevelIndex];
   }
@@ -108,9 +107,9 @@ export default class SimpleLogger {
     } = options;
 
     const hasParams =
-      level ||
-      msgPrefix ||
-      transport ||
+      level !== undefined ||
+      msgPrefix !== undefined ||
+      transport !== undefined ||
       Object.keys(bindings).length > 0 ||
       Object.keys(restOptions).length > 0;
     const effectiveBindings = {
@@ -229,7 +228,14 @@ export default class SimpleLogger {
     const prepared = prepareLogCall(args);
 
     if (prepared !== null) {
-      (method as (...args: unknown[]) => void).apply(this.logger, prepared);
+      const [first, ...rest] = prepared;
+      if (typeof first === 'string') {
+        method(first, ...rest);
+      } else if (typeof first === 'object') {
+        const [second, ...otherRest] = rest;
+        const msg = typeof second === 'string' ? second : undefined;
+        method(first, msg, ...otherRest);
+      }
     } else {
       console.warn(`Invalid log arguments for "${level}"`, args);
     }
@@ -250,7 +256,7 @@ export default class SimpleLogger {
     const fullMsg = util.format(msg, ...rest);
 
     const ctx = Object.entries({ ...this.bindings, ...context })
-      .map(([k, v]) => `${k}=${v}`)
+      .map(([k, v]) => `${k}=${String(v)}`)
       .join(' ');
 
     const prefix = `[${time}] ${levelStr}`;
@@ -318,11 +324,7 @@ export default class SimpleLogger {
   public child(newBindings: Record<string, unknown>): SimpleLogger {
     const merged = { ...this.bindings, ...newBindings };
 
-    if (
-      this.isExternal &&
-      typeof this.logger === 'object' &&
-      this.logger !== null
-    ) {
+    if (this.isExternal) {
       const logger = this.logger as ExternalLogger;
       const childFn = logger.child;
 
@@ -359,7 +361,25 @@ export default class SimpleLogger {
    * @return {void}
    */
   public logFunctionEnd(name?: string): void {
-    const caller = name || getCallerName();
+    const caller = name ?? getCallerName();
     this.trace(`Function end: ${caller}`);
   }
+
+  /**
+   * Flushes the logger buffer if the external logger supports it.
+   * This is useful for ensuring all buffered log entries are written before the application exits.
+   *
+   * @return {Promise<void>} A promise that resolves when the flush is complete.
+   */
+  public async flush(): Promise<void> {
+    if (!this.isExternal) {
+      return;
+    }
+
+    const logger = this.logger as ExternalLogger & { flush?: (callback: () => void) => void };
+    if (typeof logger.flush === 'function') {
+      const flushAsync = util.promisify(logger.flush.bind(logger)) as () => Promise<void>;
+      await flushAsync();
+    }
+  }
 }

package/src/helpers/helpers.ts

@@ -36,6 +36,22 @@ export function extractMessage(args: unknown[]): {
   return { msg: '', rest: [] };
 }
 
+/**
+ * Type guard to check if value is a plain object record.
+ *
+ * @param {unknown} value - The value to check.
+ * @return {value is Record<string, unknown>} True if the value is a plain object.
+ */
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    !Array.isArray(value) &&
+    (Object.getPrototypeOf(value) === Object.prototype ||
+      Object.getPrototypeOf(value) === null)
+  );
+}
+
 /**
  * Extracts the context object from the provided array of arguments.
  *
@@ -44,8 +60,8 @@ export function extractMessage(args: unknown[]): {
  */
 export function extractContext(args: unknown[]): Record<string, unknown> {
   const [first] = args;
-  if (typeof first === 'object' && first !== null && !Array.isArray(first)) {
-    return first as Record<string, unknown>;
+  if (isPlainObject(first)) {
+    return first;
   }
   return {};
 }
@@ -72,13 +88,15 @@ export function colorizeLevel(level: LoggerLevel, label: string): string {
     default:
       return label;
   }
+}
+
 /**
  * Prepares the log call by rearranging the provided arguments into a standardized format.
  *
  * @param {unknown[]} args - The array of arguments to prepare for the log call.
  * @return {PreparedLogCall} The prepared log call arguments, or null if the input is invalid.
  */
-}export function prepareLogCall(args: unknown[]): PreparedLogCall {
+export function prepareLogCall(args: unknown[]): PreparedLogCall {
   if (typeof args[0] === 'string') {
     return [args[0], ...args.slice(1)];
   }

package/src/helpers/validators.ts

@@ -1,6 +1,16 @@
 import { LoggerLevels } from '../constants/constants.js';
 import type { ExternalLogger } from '../types/simple-logger.types.js';
 
+/**
+ * Type guard to check if value is an object with properties.
+ *
+ * @param {unknown} value - The value to check.
+ * @return {value is Record<string, unknown>} True if the value is an object.
+ */
+function isObjectWithProperties(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
 /**
  * Checks if the provided logger is a valid ExternalLogger instance.
  *
@@ -10,27 +20,26 @@ import type { ExternalLogger } from '../types/simple-logger.types.js';
 export function isValidLogger(logger: unknown): logger is ExternalLogger {
   const levels = Object.values(LoggerLevels);
 
-  if (typeof logger !== 'object' || logger === null) {
+  if (!isObjectWithProperties(logger)) {
     return false;
   }
 
-  const candidate = logger as Record<string, unknown>;
-
-  return levels.some((level) => typeof candidate[level] === 'function');
+  return levels.some((level) => typeof logger[level] === 'function');
 }
 
 /**
  * Checks if the provided logger is an ExternalLogger instance with a child method.
  *
  * @param {unknown} logger - The logger to check.
- * @return {logger is ExternalLogger & { child: Function }} True if the logger is an ExternalLogger with a child method, false otherwise.
+ * @return {logger is ExternalLogger & { child: (bindings: Record<string, unknown>, options?: Record<string, unknown>) => ExternalLogger }} True if the logger is an ExternalLogger with a child method, false otherwise.
  */
 export function hasChild(
   logger: unknown
-): logger is ExternalLogger & { child: Function } {
+): logger is ExternalLogger & { child: (bindings: Record<string, unknown>, options?: Record<string, unknown>) => ExternalLogger } {
   return (
     typeof logger === 'object' &&
     logger !== null &&
-    typeof (logger as any).child === 'function'
+    'child' in logger &&
+    typeof logger.child === 'function'
   );
 }

package/src/types/simple-logger.types.ts

@@ -3,8 +3,7 @@ import type { LoggerLevels } from '../constants/constants';
 export type LoggerLevel = (typeof LoggerLevels)[keyof typeof LoggerLevels];
 
 export interface LogFn {
-  <T extends object>(obj: T, msg?: string, ...args: unknown[]): void;
-  (obj: unknown, msg?: string, ...args: unknown[]): void;
+  (obj: object, msg?: string, ...args: unknown[]): void;
   (msg: string, ...args: unknown[]): void;
 }