logan-logger 1.0.2 → 1.1.0

package/dist/node.d.ts

@@ -0,0 +1,190 @@
+declare abstract class BaseLogger implements ILogger {
+    protected level: LogLevel;
+    protected config: Partial<LoggerConfig>;
+    protected runtime: RuntimeName;
+    protected childMetadata: Record<string, any>;
+    protected constructor(config?: Partial<LoggerConfig>);
+    debug(message: LogMessage, metadata?: any): void;
+    info(message: LogMessage, metadata?: any): void;
+    warn(message: LogMessage, metadata?: any): void;
+    error(message: LogMessage, metadata?: any): void;
+    log(level: LogLevel, message: LogMessage, metadata?: any): void;
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+    child(metadata: Record<string, any>): ILogger;
+    protected shouldLog(level: LogLevel): boolean;
+    protected abstract writeLog(entry: LogEntry): void;
+    protected abstract createChild(): BaseLogger;
+}
+
+/**
+ * Convenience function for creating a logger instance.
+ * @param config - Optional configuration for the logger
+ * @returns A logger instance appropriate for the current runtime
+ * @example
+ * ```typescript
+ * import { createLogger, LogLevel } from 'logan-logger';
+ *
+ * const logger = createLogger({
+ *   level: LogLevel.DEBUG,
+ *   colorize: true
+ * });
+ *
+ * logger.info('Hello world!');
+ * ```
+ */
+export declare function createLogger(config?: Partial<LoggerConfig>): ILogger;
+
+/**
+ * Create a logger with configuration based on the current environment.
+ * Automatically detects production/development/test environments and
+ * sets appropriate log levels and formatting.
+ * @returns A logger instance configured for the current environment
+ */
+export declare function createLoggerForEnvironment(): ILogger;
+
+export declare function createMorganStream(logger: NodeLogger): {
+    write: (message: string) => void;
+};
+
+/**
+ * Main logger interface providing methods for logging at different levels.
+ * This interface is implemented by all logger implementations across different runtimes.
+ */
+export declare interface ILogger {
+    /**
+     * Log a debug message. Only shown when log level is DEBUG.
+     * @param message - The message to log (string or lazy function)
+     * @param metadata - Optional structured data to include
+     */
+    debug(message: LogMessage, metadata?: any): void;
+    /**
+     * Log an informational message.
+     * @param message - The message to log (string or lazy function)
+     * @param metadata - Optional structured data to include
+     */
+    info(message: LogMessage, metadata?: any): void;
+    /**
+     * Log a warning message.
+     * @param message - The message to log (string or lazy function)
+     * @param metadata - Optional structured data to include
+     */
+    warn(message: LogMessage, metadata?: any): void;
+    /**
+     * Log an error message.
+     * @param message - The message to log (string or lazy function)
+     * @param metadata - Optional structured data to include
+     */
+    error(message: LogMessage, metadata?: any): void;
+    /**
+     * Log a message at a specific level.
+     * @param level - The log level
+     * @param message - The message to log (string or lazy function)
+     * @param metadata - Optional structured data to include
+     */
+    log(level: LogLevel, message: LogMessage, metadata?: any): void;
+    /**
+     * Set the minimum log level for this logger.
+     * @param level - The minimum log level
+     */
+    setLevel(level: LogLevel): void;
+    /**
+     * Get the current minimum log level.
+     * @returns The current log level
+     */
+    getLevel(): LogLevel;
+    /**
+     * Create a child logger with additional metadata.
+     * @param metadata - Additional metadata to include in all child log messages
+     * @returns A new logger instance with the additional metadata
+     */
+    child(metadata: Record<string, any>): ILogger;
+}
+
+/**
+ * Internal representation of a log entry.
+ */
+declare interface LogEntry {
+    /** When the log entry was created */
+    timestamp: Date;
+    /** Log level of this entry */
+    level: LogLevel;
+    /** The log message */
+    message: string;
+    /** Additional structured data */
+    metadata?: Record<string, any>;
+    /** Runtime that generated this log entry */
+    runtime: RuntimeName;
+}
+
+/**
+ * Configuration options for creating a logger instance.
+ */
+export declare interface LoggerConfig {
+    /** Minimum log level to output */
+    level: LogLevel;
+    /** Output format for log messages */
+    format: 'json' | 'text' | 'custom';
+    /** Whether to include timestamps in log output */
+    timestamp: boolean;
+    /** Whether to colorize log output (if supported) */
+    colorize: boolean;
+    /** Default metadata to include with all log messages */
+    metadata: Record<string, any>;
+    /** Transport configurations for log output */
+    transports?: TransportConfig[];
+}
+
+/**
+ * Log levels in ascending order of severity.
+ * Used to filter which messages should be logged.
+ */
+export declare enum LogLevel {
+    /** Debug messages - most verbose */
+    DEBUG = 0,
+    /** Informational messages */
+    INFO = 1,
+    /** Warning messages */
+    WARN = 2,
+    /** Error messages */
+    ERROR = 3,
+    /** No messages - silent mode */
+    SILENT = 4
+}
+
+/**
+ * A log message can be a string or a function that returns a string.
+ * Functions enable lazy evaluation for expensive log message generation.
+ */
+declare type LogMessage = string | (() => string);
+
+export declare class NodeLogger extends BaseLogger {
+    private winston?;
+    constructor(config?: Partial<LoggerConfig>);
+    private initializeWinston;
+    private createWinstonLogger;
+    protected writeLog(entry: LogEntry): void;
+    protected createChild(): BaseLogger;
+    private writeToConsole;
+    private getWinstonLevel;
+    setLevel(level: LogLevel): void;
+}
+
+/**
+ * Supported JavaScript runtime environments.
+ */
+declare type RuntimeName = 'node' | 'deno' | 'bun' | 'browser' | 'webworker' | 'unknown';
+
+/**
+ * Configuration for a specific log transport (output destination).
+ */
+declare interface TransportConfig {
+    /** Type of transport */
+    type: 'console' | 'file' | 'http' | 'custom';
+    /** Minimum log level for this transport */
+    level?: LogLevel;
+    /** Transport-specific options */
+    options: Record<string, any>;
+}
+
+export { }

package/dist/node.esm.js

@@ -0,0 +1,7 @@
+import { N as a, a as o, c as g, r as t } from "./node-BqvVrzA_.mjs";
+export {
+  a as NodeLogger,
+  o as createLogger,
+  g as createLoggerForEnvironment,
+  t as createMorganStream
+};

package/dist/node.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./node-BKsollr4.js");exports.NodeLogger=e.NodeLogger;exports.createLogger=e.createLogger;exports.createLoggerForEnvironment=e.createLoggerForEnvironment;exports.createMorganStream=e.createMorganStream;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logan-logger",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Universal TypeScript logging library for all JavaScript runtimes",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
@@ -10,6 +10,26 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.esm.js",
       "require": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.esm.js",
+      "require": "./dist/node.js"
+    },
+    "./deno": {
+      "types": "./dist/deno.d.ts",
+      "import": "./dist/deno.esm.js",
+      "require": "./dist/deno.js"
+    },
+    "./bun": {
+      "types": "./dist/bun.d.ts",
+      "import": "./dist/bun.esm.js",
+      "require": "./dist/bun.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.esm.js",
+      "require": "./dist/browser.js"
     }
   },
   "keywords": [