@fimbul-works/logger 1.0.0 → 1.0.1

package/dist/cjs/index.d.ts

@@ -0,0 +1,77 @@
+import pino, { type Logger as Pino } from "pino";
+/**
+ * Log level.
+ */
+export type LogLevel = "info" | "error" | "warn" | "debug";
+/**
+ * Configuration options for the Logger.
+ */
+export interface LoggerOptions extends pino.LoggerOptions {
+    /**
+     * Optional name label (e.g., "http")
+     */
+    name?: string;
+    /**
+     * Optional log level (e.g., "info"), default: "info"
+     */
+    level?: string;
+    /**
+     * Optional targets, default: STDOUT & STDERR, disabled when NODE_ENV="test"
+     */
+    targets?: pino.TransportTargetOptions[];
+}
+/**
+ * A wrapper around Pino to provide a consistent logging interface.
+ */
+export declare class Logger {
+    /**
+     * pino instance.
+     *
+     * @private
+     * @type {Pino}
+     */
+    private logger;
+    /**
+     * Creates a new Logger instance.
+     *
+     * @param {LoggerOptions} options - Optional configuration options for the logger
+     */
+    constructor(options?: pino.LoggerOptions);
+    /**
+     * Logs a message at the specified level.
+     *
+     * @param {LogLevel} level - The log level.
+     */
+    log(level: LogLevel, ...args: any[]): void;
+    /**
+     * Logs a message at the `info` level.
+     */
+    info(...args: any[]): void;
+    /**
+     * Logs a message at the `error` level.
+     */
+    error(...args: any[]): void;
+    /**
+     * Logs a message at the `warn` level.
+     */
+    warn(...args: any[]): void;
+    /**
+     * Logs a message at the `debug` level.
+     */
+    debug(...args: any[]): void;
+    /**
+     * Returns the underlying Pino logger instance.
+     *
+     * @returns {Pino} The Pino logger instance.
+     */
+    getRawLogger(): Pino;
+    /**
+     * Handles logging by parsing arguments and calling the appropriate Pino method.
+     *
+     * @private
+     * @param {LogLevel} level
+     * @param {any[]} args
+     */
+    private handleLog;
+}
+export default Logger;

package/dist/cjs/index.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const pino_1 = __importDefault(require("pino"));
+/**
+ * A wrapper around Pino to provide a consistent logging interface.
+ */
+class Logger {
+    /**
+     * Creates a new Logger instance.
+     *
+     * @param {LoggerOptions} options - Optional configuration options for the logger
+     */
+    constructor(options = {}) {
+        this.logger = (0, pino_1.default)({
+            level: "info",
+            ...options,
+            transport: {
+                targets: process.env.NODE_ENV !== "test"
+                    ? [
+                        {
+                            target: "pino/file",
+                            options: { destination: 1 }, // STDOUT
+                            level: options.level || "info",
+                        },
+                        {
+                            target: "pino/file",
+                            options: { destination: 2 }, // STDERR
+                            level: "error",
+                        },
+                    ]
+                    : [],
+                ...options.transport,
+            },
+        });
+    }
+    /**
+     * Logs a message at the specified level.
+     *
+     * @param {LogLevel} level - The log level.
+     */
+    log(level, ...args) {
+        this.handleLog(level, args);
+    }
+    /**
+     * Logs a message at the `info` level.
+     */
+    info(...args) {
+        this.handleLog("info", args);
+    }
+    /**
+     * Logs a message at the `error` level.
+     */
+    error(...args) {
+        this.handleLog("error", args);
+    }
+    /**
+     * Logs a message at the `warn` level.
+     */
+    warn(...args) {
+        this.handleLog("warn", args);
+    }
+    /**
+     * Logs a message at the `debug` level.
+     */
+    debug(...args) {
+        this.handleLog("debug", args);
+    }
+    /**
+     * Returns the underlying Pino logger instance.
+     *
+     * @returns {Pino} The Pino logger instance.
+     */
+    getRawLogger() {
+        return this.logger;
+    }
+    /**
+     * Handles logging by parsing arguments and calling the appropriate Pino method.
+     *
+     * @private
+     * @param {LogLevel} level
+     * @param {any[]} args
+     */
+    handleLog(level, args) {
+        if (args.length === 0) {
+            this.logger[level]("");
+            return;
+        }
+        const [first, ...rest] = args;
+        // Case 1: Object first -> Pass through (Standard Pino)
+        // logger.info({ id: 1 }, "msg")
+        if (typeof first === "object" && first !== null) {
+            this.logger[level](first, ...rest);
+            return;
+        }
+        // Case 2: String first
+        if (typeof first === "string") {
+            // Check for printf-style formatting
+            // Simple heuristic: if string contains %, treat as printf and pass through
+            if (first.includes("%") && rest.length > 0) {
+                this.logger[level](first, ...rest);
+                return;
+            }
+            // Check for (msg, obj) pattern -> Swap to (obj, msg) (Console style)
+            if (rest.length === 1 && typeof rest[0] === "object" && rest[0] !== null) {
+                this.logger[level](rest[0], first);
+                return;
+            }
+            // Check for (msg, ...vars) pattern -> Wrap in payload
+            if (rest.length > 0) {
+                this.logger[level]({ args: rest }, first);
+                return;
+            }
+            // Just a single string message
+            this.logger[level](first);
+            return;
+        }
+        // Case 3: Primitive first (non-string output) -> Wrap in payload
+        // logger.info(1, true)
+        this.logger[level]({ args }, "Log event");
+    }
+}
+exports.Logger = Logger;
+exports.default = Logger;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/esm/index.d.ts

@@ -0,0 +1,77 @@
+import pino, { type Logger as Pino } from "pino";
+/**
+ * Log level.
+ */
+export type LogLevel = "info" | "error" | "warn" | "debug";
+/**
+ * Configuration options for the Logger.
+ */
+export interface LoggerOptions extends pino.LoggerOptions {
+    /**
+     * Optional name label (e.g., "http")
+     */
+    name?: string;
+    /**
+     * Optional log level (e.g., "info"), default: "info"
+     */
+    level?: string;
+    /**
+     * Optional targets, default: STDOUT & STDERR, disabled when NODE_ENV="test"
+     */
+    targets?: pino.TransportTargetOptions[];
+}
+/**
+ * A wrapper around Pino to provide a consistent logging interface.
+ */
+export declare class Logger {
+    /**
+     * pino instance.
+     *
+     * @private
+     * @type {Pino}
+     */
+    private logger;
+    /**
+     * Creates a new Logger instance.
+     *
+     * @param {LoggerOptions} options - Optional configuration options for the logger
+     */
+    constructor(options?: pino.LoggerOptions);
+    /**
+     * Logs a message at the specified level.
+     *
+     * @param {LogLevel} level - The log level.
+     */
+    log(level: LogLevel, ...args: any[]): void;
+    /**
+     * Logs a message at the `info` level.
+     */
+    info(...args: any[]): void;
+    /**
+     * Logs a message at the `error` level.
+     */
+    error(...args: any[]): void;
+    /**
+     * Logs a message at the `warn` level.
+     */
+    warn(...args: any[]): void;
+    /**
+     * Logs a message at the `debug` level.
+     */
+    debug(...args: any[]): void;
+    /**
+     * Returns the underlying Pino logger instance.
+     *
+     * @returns {Pino} The Pino logger instance.
+     */
+    getRawLogger(): Pino;
+    /**
+     * Handles logging by parsing arguments and calling the appropriate Pino method.
+     *
+     * @private
+     * @param {LogLevel} level
+     * @param {any[]} args
+     */
+    private handleLog;
+}
+export default Logger;

package/dist/esm/index.js

@@ -0,0 +1,120 @@
+import pino from "pino";
+/**
+ * A wrapper around Pino to provide a consistent logging interface.
+ */
+export class Logger {
+    /**
+     * Creates a new Logger instance.
+     *
+     * @param {LoggerOptions} options - Optional configuration options for the logger
+     */
+    constructor(options = {}) {
+        this.logger = pino({
+            level: "info",
+            ...options,
+            transport: {
+                targets: process.env.NODE_ENV !== "test"
+                    ? [
+                        {
+                            target: "pino/file",
+                            options: { destination: 1 }, // STDOUT
+                            level: options.level || "info",
+                        },
+                        {
+                            target: "pino/file",
+                            options: { destination: 2 }, // STDERR
+                            level: "error",
+                        },
+                    ]
+                    : [],
+                ...options.transport,
+            },
+        });
+    }
+    /**
+     * Logs a message at the specified level.
+     *
+     * @param {LogLevel} level - The log level.
+     */
+    log(level, ...args) {
+        this.handleLog(level, args);
+    }
+    /**
+     * Logs a message at the `info` level.
+     */
+    info(...args) {
+        this.handleLog("info", args);
+    }
+    /**
+     * Logs a message at the `error` level.
+     */
+    error(...args) {
+        this.handleLog("error", args);
+    }
+    /**
+     * Logs a message at the `warn` level.
+     */
+    warn(...args) {
+        this.handleLog("warn", args);
+    }
+    /**
+     * Logs a message at the `debug` level.
+     */
+    debug(...args) {
+        this.handleLog("debug", args);
+    }
+    /**
+     * Returns the underlying Pino logger instance.
+     *
+     * @returns {Pino} The Pino logger instance.
+     */
+    getRawLogger() {
+        return this.logger;
+    }
+    /**
+     * Handles logging by parsing arguments and calling the appropriate Pino method.
+     *
+     * @private
+     * @param {LogLevel} level
+     * @param {any[]} args
+     */
+    handleLog(level, args) {
+        if (args.length === 0) {
+            this.logger[level]("");
+            return;
+        }
+        const [first, ...rest] = args;
+        // Case 1: Object first -> Pass through (Standard Pino)
+        // logger.info({ id: 1 }, "msg")
+        if (typeof first === "object" && first !== null) {
+            this.logger[level](first, ...rest);
+            return;
+        }
+        // Case 2: String first
+        if (typeof first === "string") {
+            // Check for printf-style formatting
+            // Simple heuristic: if string contains %, treat as printf and pass through
+            if (first.includes("%") && rest.length > 0) {
+                this.logger[level](first, ...rest);
+                return;
+            }
+            // Check for (msg, obj) pattern -> Swap to (obj, msg) (Console style)
+            if (rest.length === 1 && typeof rest[0] === "object" && rest[0] !== null) {
+                this.logger[level](rest[0], first);
+                return;
+            }
+            // Check for (msg, ...vars) pattern -> Wrap in payload
+            if (rest.length > 0) {
+                this.logger[level]({ args: rest }, first);
+                return;
+            }
+            // Just a single string message
+            this.logger[level](first);
+            return;
+        }
+        // Case 3: Primitive first (non-string output) -> Wrap in payload
+        // logger.info(1, true)
+        this.logger[level]({ args }, "Log event");
+    }
+}
+export default Logger;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fimbul-works/logger",
-  "description": "Simple wrapper for Pino",
-  "version": "1.0.0",
+  "description": "A lightweight, TypeScript-friendly wrapper around Pino that provides flexible logging patterns with automatic argument handling",
+  "version": "1.0.1",
   "type": "module",
   "private": false,
   "license": "MIT",
@@ -19,14 +19,22 @@
     "logger",
     "typescript"
   ],
-  "scripts": {
-    "build": "rm -rf dist && pnpm build:esm && pnpm build:cjs",
-    "build:esm": "tsc -p tsconfig.json",
-    "build:cjs": "tsc -p tsconfig.cjs.json && echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json",
-    "format": "biome format --write",
-    "test": "NODE_ENV=test vitest run",
-    "prepublishOnly": "npm run build"
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
   },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
   "dependencies": {
     "pino": "^10.3.0"
   },
@@ -35,5 +43,12 @@
     "@types/node": "^25.2.1",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "rm -rf dist && pnpm build:esm && pnpm build:cjs",
+    "build:esm": "tsc -p tsconfig.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json && echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json",
+    "format": "biome format --write",
+    "test": "NODE_ENV=test vitest run"
   }
-}
+}

package/biome.json

@@ -1,15 +0,0 @@
-{
-  "formatter": {
-    "indentStyle": "space",
-    "indentWidth": 2,
-    "lineWidth": 120,
-    "lineEnding": "lf"
-  },
-  "linter": {
-    "rules": {
-      "suspicious": {
-        "noExplicitAny": "off"
-      }
-    }
-  }
-}

package/src/index.test.ts

@@ -1,87 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { Logger } from "./index";
-
-// Mock Pino
-vi.mock("pino", () => {
-  const info = vi.fn();
-  const error = vi.fn();
-  const warn = vi.fn();
-  const debug = vi.fn();
-  const logger = { info, error, warn, debug };
-  return {
-    default: vi.fn(() => logger),
-  };
-});
-
-describe("Logger", () => {
-  it("should log info messages", () => {
-    const logger = new Logger();
-    logger.info("Hello world");
-
-    const rawLogger = logger.getRawLogger();
-    expect(rawLogger.info).toHaveBeenCalledWith("Hello world");
-  });
-
-  it("should log error messages", () => {
-    const logger = new Logger();
-    const err = new Error("Test error");
-
-    logger.error("Something went wrong", err);
-
-    const rawLogger = logger.getRawLogger();
-    expect(rawLogger.error).toHaveBeenCalledWith(err, "Something went wrong");
-  });
-
-  describe("Smart Argument Handling", () => {
-    it("should swap args when calling (msg, obj)", () => {
-      const logger = new Logger();
-      const rawLogger = logger.getRawLogger();
-      const obj = { id: 123 };
-
-      logger.info("User login", obj);
-
-      // Expect swap: (obj, msg)
-      expect(rawLogger.info).toHaveBeenCalledWith(obj, "User login");
-    });
-
-    it("should wrap multiple args in payload object", () => {
-      const logger = new Logger();
-      const rawLogger = logger.getRawLogger();
-
-      logger.info("Values", 1, true, "extra");
-
-      // Expect wrap: ({ args: [1, true, "extra"] }, msg)
-      expect(rawLogger.info).toHaveBeenCalledWith({ args: [1, true, "extra"] }, "Values");
-    });
-
-    it("should respect printf style formatting", () => {
-      const logger = new Logger();
-      const rawLogger = logger.getRawLogger();
-
-      logger.info("User %s logged in", "Alice");
-
-      // Expect pass-through: (msg, ...args)
-      expect(rawLogger.info).toHaveBeenCalledWith("User %s logged in", "Alice");
-    });
-
-    it("should handle mixed printf and extra args (best effort)", () => {
-      const logger = new Logger();
-      const rawLogger = logger.getRawLogger();
-
-      // If user mixes printf with too many args, we just pass through and let Pino handle/ignore
-      logger.info("User %s", "Alice", "ExtraIgnored");
-
-      expect(rawLogger.info).toHaveBeenCalledWith("User %s", "Alice", "ExtraIgnored");
-    });
-
-    it("should pass through (obj, msg) as is", () => {
-      const logger = new Logger();
-      const rawLogger = logger.getRawLogger();
-      const obj = { id: 1 };
-
-      logger.info(obj, "Message");
-
-      expect(rawLogger.info).toHaveBeenCalledWith(obj, "Message");
-    });
-  });
-});

package/src/index.ts

@@ -1,170 +0,0 @@
-import pino, { type Logger as Pino } from "pino";
-
-/**
- * Log level.
- */
-export type LogLevel = "info" | "error" | "warn" | "debug";
-
-/**
- * Configuration options for the Logger.
- */
-export interface LoggerOptions extends pino.LoggerOptions {
-  /**
-   * Optional name label (e.g., "http")
-   */
-  name?: string;
-
-  /**
-   * Optional log level (e.g., "info"), default: "info"
-   */
-  level?: string;
-
-  /**
-   * Optional targets, default: STDOUT & STDERR, disabled when NODE_ENV="test"
-   */
-  targets?: pino.TransportTargetOptions[];
-}
-
-/**
- * A wrapper around Pino to provide a consistent logging interface.
- */
-export class Logger {
-  /**
-   * pino instance.
-   *
-   * @private
-   * @type {Pino}
-   */
-  private logger: Pino;
-
-  /**
-   * Creates a new Logger instance.
-   *
-   * @param {LoggerOptions} options - Optional configuration options for the logger
-   */
-  constructor(options: pino.LoggerOptions = {}) {
-    this.logger = pino({
-      level: "info",
-      ...options,
-      transport: {
-        targets:
-          process.env.NODE_ENV !== "test"
-            ? [
-                {
-                  target: "pino/file",
-                  options: { destination: 1 }, // STDOUT
-                  level: options.level || "info",
-                },
-                {
-                  target: "pino/file",
-                  options: { destination: 2 }, // STDERR
-                  level: "error",
-                },
-              ]
-            : [],
-        ...options.transport,
-      },
-    });
-  }
-
-  /**
-   * Logs a message at the specified level.
-   *
-   * @param {LogLevel} level - The log level.
-   */
-  public log(level: LogLevel, ...args: any[]): void {
-    this.handleLog(level, args);
-  }
-
-  /**
-   * Logs a message at the `info` level.
-   */
-  public info(...args: any[]): void {
-    this.handleLog("info", args);
-  }
-
-  /**
-   * Logs a message at the `error` level.
-   */
-  public error(...args: any[]): void {
-    this.handleLog("error", args);
-  }
-
-  /**
-   * Logs a message at the `warn` level.
-   */
-  public warn(...args: any[]): void {
-    this.handleLog("warn", args);
-  }
-
-  /**
-   * Logs a message at the `debug` level.
-   */
-  public debug(...args: any[]): void {
-    this.handleLog("debug", args);
-  }
-
-  /**
-   * Returns the underlying Pino logger instance.
-   *
-   * @returns {Pino} The Pino logger instance.
-   */
-  public getRawLogger(): Pino {
-    return this.logger;
-  }
-
-  /**
-   * Handles logging by parsing arguments and calling the appropriate Pino method.
-   *
-   * @private
-   * @param {LogLevel} level
-   * @param {any[]} args
-   */
-  private handleLog(level: LogLevel, args: any[]): void {
-    if (args.length === 0) {
-      this.logger[level]("");
-      return;
-    }
-
-    const [first, ...rest] = args;
-
-    // Case 1: Object first -> Pass through (Standard Pino)
-    // logger.info({ id: 1 }, "msg")
-    if (typeof first === "object" && first !== null) {
-      this.logger[level](first, ...rest);
-      return;
-    }
-
-    // Case 2: String first
-    if (typeof first === "string") {
-      // Check for printf-style formatting
-      // Simple heuristic: if string contains %, treat as printf and pass through
-      if (first.includes("%") && rest.length > 0) {
-        this.logger[level](first, ...rest);
-        return;
-      }
-
-      // Check for (msg, obj) pattern -> Swap to (obj, msg) (Console style)
-      if (rest.length === 1 && typeof rest[0] === "object" && rest[0] !== null) {
-        this.logger[level](rest[0], first);
-        return;
-      }
-
-      // Check for (msg, ...vars) pattern -> Wrap in payload
-      if (rest.length > 0) {
-        this.logger[level]({ args: rest }, first);
-        return;
-      }
-
-      // Just a single string message
-      this.logger[level](first);
-      return;
-    }
-
-    // Case 3: Primitive first (non-string output) -> Wrap in payload
-    // logger.info(1, true)
-    this.logger[level]({ args }, "Log event");
-  }
-}
-
-export default Logger;

package/tsconfig.cjs.json

@@ -1,9 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "outDir": "dist/cjs",
-    "verbatimModuleSyntax": false
-  }
-}

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ES2020",
-    "lib": ["ES2020"],
-    "moduleResolution": "Bundler",
-    "declaration": true,
-    "allowJs": true,
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "outDir": "./dist/esm/"
-  },
-  "include": ["src"],
-  "exclude": ["src/**/*.test.ts", "node_modules"]
-}