@vvlad1973/simple-logger 2.1.10 → 2.2.1

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,31 @@ 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') {
+        // Call with string message signature: (msg: string, ...args: unknown[])
+        method.call(this.logger, first, ...rest);
+      } else if (typeof first === 'object') {
+        // Call with object signature: (obj: object, msg?: string, ...args: unknown[])
+        const [second, ...otherRest] = rest;
+        if (typeof second === 'string') {
+          // Call with both object and message
+          (method as (obj: object, msg: string, ...args: unknown[]) => void).call(
+            this.logger,
+            first,
+            second,
+            ...otherRest
+          );
+        } else {
+          // Call with object only (msg is undefined)
+          (method as (obj: object, msg?: string, ...args: unknown[]) => void).call(
+            this.logger,
+            first,
+            undefined,
+            ...otherRest
+          );
+        }
+      }
     } else {
       console.warn(`Invalid log arguments for "${level}"`, args);
     }
@@ -250,7 +273,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 +341,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 +378,32 @@ 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: (err?: Error) => void) => void;
+    };
+
+    if (typeof logger.flush === 'function') {
+      try {
+        const promisifiedFlush = util.promisify(logger.flush.bind(logger));
+        return await promisifiedFlush();
+      } catch {
+        // Ignore flush errors - they're not critical
+      }
+    }
+  }
 }

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;
 }
 

package/tsconfig.json

@@ -11,7 +11,8 @@
     "sourceMap": true,
     "resolveJsonModule": true,
     "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node", "vitest/globals"]
   },
   "include": [
     "src/**/*"

package/vitest.config.ts

@@ -12,6 +12,7 @@ export default defineConfig({
     include: ['src/**/*.test.ts'],
     exclude: ['node_modules/**', 'dist/**', 'docs/**'],
     coverage: {
+      enabled: true,
       provider: 'v8',
       reporter: ['text', 'json', 'html', 'lcov'],
       include: ['src/**/*.ts'],
@@ -22,7 +23,6 @@ export default defineConfig({
         '**/*.test.ts',
         '**/*.config.ts',
         '**/*.config.js',
-        'src/__test__/**'
       ],
       thresholds: {
         lines: 80,