@carno.js/logger 1.0.0 → 1.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 carno.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/LoggerPlugin.d.ts

@@ -0,0 +1,39 @@
+import { Carno } from '@carno.js/core/Carno';
+import { LoggerService, LoggerConfig } from './LoggerService';
+/**
+ * Logger plugin configuration.
+ */
+export interface LoggerPluginConfig extends LoggerConfig {
+    /** Auto-register as singleton in DI */
+    autoRegister?: boolean;
+}
+/**
+ * Create a logger plugin for Turbo.
+ *
+ * @example
+ * ```typescript
+ * const app = new Turbo();
+ * app.use(createLoggerPlugin({ level: LogLevel.DEBUG }));
+ *
+ * // Now LoggerService is available for injection
+ * @Controller()
+ * class MyController {
+ *   constructor(private logger: LoggerService) {}
+ *
+ *   @Get('/')
+ *   index() {
+ *     this.logger.info('Request received', { path: '/' });
+ *     return 'Hello';
+ *   }
+ * }
+ * ```
+ */
+export declare function createCarnoLogger(config?: LoggerPluginConfig): Carno;
+export declare const CarnoLogger: Carno;
+/**
+ * Create a standalone logger (without Turbo).
+ */
+export declare function createLogger(config?: LoggerConfig): LoggerService;
+export { LoggerService, LogLevel } from './LoggerService';
+export type { LoggerConfig } from './LoggerService';
+export type { LogData } from './LoggerService';

package/dist/LoggerPlugin.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = exports.LoggerService = exports.CarnoLogger = void 0;
+exports.createCarnoLogger = createCarnoLogger;
+exports.createLogger = createLogger;
+const Carno_1 = require("@carno.js/core/Carno");
+const LoggerService_1 = require("./LoggerService");
+/**
+ * Create a logger plugin for Turbo.
+ *
+ * @example
+ * ```typescript
+ * const app = new Turbo();
+ * app.use(createLoggerPlugin({ level: LogLevel.DEBUG }));
+ *
+ * // Now LoggerService is available for injection
+ * @Controller()
+ * class MyController {
+ *   constructor(private logger: LoggerService) {}
+ *
+ *   @Get('/')
+ *   index() {
+ *     this.logger.info('Request received', { path: '/' });
+ *     return 'Hello';
+ *   }
+ * }
+ * ```
+ */
+function createCarnoLogger(config = {}) {
+    const logger = new LoggerService_1.LoggerService(config);
+    return new Carno_1.Carno()
+        .services([
+        {
+            token: LoggerService_1.LoggerService,
+            useValue: logger
+        }
+    ]);
+}
+exports.CarnoLogger = createCarnoLogger();
+/**
+ * Create a standalone logger (without Turbo).
+ */
+function createLogger(config = {}) {
+    return new LoggerService_1.LoggerService(config);
+}
+// Re-export everything
+var LoggerService_2 = require("./LoggerService");
+Object.defineProperty(exports, "LoggerService", { enumerable: true, get: function () { return LoggerService_2.LoggerService; } });
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return LoggerService_2.LogLevel; } });

package/dist/LoggerService.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Log levels.
+ */
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    FATAL = 4,
+    SILENT = 5
+}
+/**
+ * Logger configuration.
+ */
+export interface LoggerConfig {
+    /** Minimum log level to output */
+    level?: LogLevel | keyof typeof LogLevel;
+    /** Pretty print structured data */
+    pretty?: boolean;
+    /** Include timestamp */
+    timestamp?: boolean;
+    /** Custom timestamp format function */
+    timestampFormat?: () => string;
+    /** Prefix for all messages */
+    prefix?: string;
+    /** Async buffer flush interval (ms). 0 = sync */
+    flushInterval?: number;
+}
+/**
+ * Structured log data.
+ */
+export type LogData = Record<string, any>;
+/**
+ * High-performance async logger.
+ *
+ * Features:
+ * - Async buffered output (like Pino)
+ * - Structured JSON data support
+ * - Beautiful colorized output
+ * - Zero-allocation hot path
+ *
+ * @example
+ * ```typescript
+ * const logger = new LoggerService({ level: LogLevel.DEBUG });
+ *
+ * logger.info('User logged in', { userId: 123, ip: '192.168.1.1' });
+ * logger.error('Database error', { error: err.message, query: sql });
+ * ```
+ */
+export declare class LoggerService {
+    private level;
+    private pretty;
+    private timestamp;
+    private timestampFormat;
+    private prefix;
+    private buffer;
+    private flushTimer;
+    private flushInterval;
+    constructor(config?: LoggerConfig);
+    /**
+     * Debug level log.
+     */
+    debug(message: string, data?: LogData): void;
+    /**
+     * Info level log.
+     */
+    info(message: string, data?: LogData): void;
+    /**
+     * Warning level log.
+     */
+    warn(message: string, data?: LogData): void;
+    /**
+     * Error level log.
+     */
+    error(message: string, data?: LogData): void;
+    /**
+     * Fatal level log (will also flush immediately).
+     */
+    fatal(message: string, data?: LogData): void;
+    /**
+     * Log with custom level.
+     */
+    log(level: LogLevel, message: string, data?: LogData): void;
+    /**
+     * Set minimum log level.
+     */
+    setLevel(level: LogLevel | keyof typeof LogLevel): void;
+    /**
+     * Flush buffered logs.
+     */
+    flush(): void;
+    /**
+     * Close the logger (flush and stop timer).
+     */
+    close(): void;
+    private write;
+    private formatLine;
+    private formatDataPretty;
+    private formatValue;
+    private defaultTimestamp;
+    private parseLevel;
+}

package/dist/LoggerService.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerService = exports.LogLevel = void 0;
+/**
+ * Log levels.
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["FATAL"] = 4] = "FATAL";
+    LogLevel[LogLevel["SILENT"] = 5] = "SILENT";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+// ANSI color codes for beautiful output
+const COLORS = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    // Levels
+    debug: '\x1b[36m', // Cyan
+    info: '\x1b[32m', // Green
+    warn: '\x1b[33m', // Yellow
+    error: '\x1b[31m', // Red
+    fatal: '\x1b[35m', // Magenta
+    // Data
+    key: '\x1b[90m', // Gray
+    string: '\x1b[33m', // Yellow
+    number: '\x1b[36m', // Cyan
+    boolean: '\x1b[35m', // Magenta
+    null: '\x1b[90m', // Gray
+};
+const LEVEL_LABELS = {
+    [LogLevel.DEBUG]: `${COLORS.debug}${COLORS.bold}DEBUG${COLORS.reset}`,
+    [LogLevel.INFO]: `${COLORS.info}${COLORS.bold}INFO${COLORS.reset} `,
+    [LogLevel.WARN]: `${COLORS.warn}${COLORS.bold}WARN${COLORS.reset} `,
+    [LogLevel.ERROR]: `${COLORS.error}${COLORS.bold}ERROR${COLORS.reset}`,
+    [LogLevel.FATAL]: `${COLORS.fatal}${COLORS.bold}FATAL${COLORS.reset}`,
+    [LogLevel.SILENT]: '',
+};
+const LEVEL_ICONS = {
+    [LogLevel.DEBUG]: '🔍',
+    [LogLevel.INFO]: '✨',
+    [LogLevel.WARN]: '⚠️ ',
+    [LogLevel.ERROR]: '❌',
+    [LogLevel.FATAL]: '💀',
+    [LogLevel.SILENT]: '',
+};
+/**
+ * High-performance async logger.
+ *
+ * Features:
+ * - Async buffered output (like Pino)
+ * - Structured JSON data support
+ * - Beautiful colorized output
+ * - Zero-allocation hot path
+ *
+ * @example
+ * ```typescript
+ * const logger = new LoggerService({ level: LogLevel.DEBUG });
+ *
+ * logger.info('User logged in', { userId: 123, ip: '192.168.1.1' });
+ * logger.error('Database error', { error: err.message, query: sql });
+ * ```
+ */
+class LoggerService {
+    constructor(config = {}) {
+        this.buffer = [];
+        this.flushTimer = null;
+        this.level = this.parseLevel(config.level ?? LogLevel.INFO);
+        this.pretty = config.pretty ?? true;
+        this.timestamp = config.timestamp ?? true;
+        this.timestampFormat = config.timestampFormat ?? this.defaultTimestamp;
+        this.prefix = config.prefix ?? '';
+        this.flushInterval = config.flushInterval ?? 10;
+        if (this.flushInterval > 0) {
+            this.flushTimer = setInterval(() => this.flush(), this.flushInterval);
+        }
+    }
+    /**
+     * Debug level log.
+     */
+    debug(message, data) {
+        this.log(LogLevel.DEBUG, message, data);
+    }
+    /**
+     * Info level log.
+     */
+    info(message, data) {
+        this.log(LogLevel.INFO, message, data);
+    }
+    /**
+     * Warning level log.
+     */
+    warn(message, data) {
+        this.log(LogLevel.WARN, message, data);
+    }
+    /**
+     * Error level log.
+     */
+    error(message, data) {
+        this.log(LogLevel.ERROR, message, data);
+    }
+    /**
+     * Fatal level log (will also flush immediately).
+     */
+    fatal(message, data) {
+        this.log(LogLevel.FATAL, message, data);
+        this.flush(); // Flush immediately for fatal
+    }
+    /**
+     * Log with custom level.
+     */
+    log(level, message, data) {
+        if (level < this.level)
+            return;
+        const line = this.formatLine(level, message, data);
+        if (this.flushInterval === 0) {
+            // Sync mode
+            this.write(line, level);
+        }
+        else {
+            // Async mode
+            this.buffer.push(line);
+        }
+    }
+    /**
+     * Set minimum log level.
+     */
+    setLevel(level) {
+        this.level = this.parseLevel(level);
+    }
+    /**
+     * Flush buffered logs.
+     */
+    flush() {
+        if (this.buffer.length === 0)
+            return;
+        const output = this.buffer.join('\n');
+        this.buffer = [];
+        process.stdout.write(output + '\n');
+    }
+    /**
+     * Close the logger (flush and stop timer).
+     */
+    close() {
+        this.flush();
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+    write(line, level) {
+        if (level >= LogLevel.ERROR) {
+            process.stderr.write(line + '\n');
+        }
+        else {
+            process.stdout.write(line + '\n');
+        }
+    }
+    formatLine(level, message, data) {
+        const parts = [];
+        // Icon
+        parts.push(LEVEL_ICONS[level]);
+        // Timestamp
+        if (this.timestamp) {
+            parts.push(`${COLORS.dim}${this.timestampFormat()}${COLORS.reset}`);
+        }
+        // Level label
+        parts.push(LEVEL_LABELS[level]);
+        // Prefix
+        if (this.prefix) {
+            parts.push(`${COLORS.bold}[${this.prefix}]${COLORS.reset}`);
+        }
+        // Message
+        parts.push(message);
+        // Data
+        if (data && Object.keys(data).length > 0) {
+            if (this.pretty) {
+                parts.push(this.formatDataPretty(data));
+            }
+            else {
+                parts.push(`${COLORS.dim}${JSON.stringify(data)}${COLORS.reset}`);
+            }
+        }
+        return parts.join(' ');
+    }
+    formatDataPretty(data) {
+        const formatted = [];
+        for (const [key, value] of Object.entries(data)) {
+            const formattedValue = this.formatValue(value);
+            formatted.push(`${COLORS.key}${key}=${COLORS.reset}${formattedValue}`);
+        }
+        return formatted.join(' ');
+    }
+    formatValue(value) {
+        if (value === null) {
+            return `${COLORS.null}null${COLORS.reset}`;
+        }
+        if (value === undefined) {
+            return `${COLORS.null}undefined${COLORS.reset}`;
+        }
+        if (typeof value === 'string') {
+            return `${COLORS.string}"${value}"${COLORS.reset}`;
+        }
+        if (typeof value === 'number') {
+            return `${COLORS.number}${value}${COLORS.reset}`;
+        }
+        if (typeof value === 'boolean') {
+            return `${COLORS.boolean}${value}${COLORS.reset}`;
+        }
+        if (Array.isArray(value)) {
+            return `${COLORS.dim}[${value.length} items]${COLORS.reset}`;
+        }
+        if (typeof value === 'object') {
+            return `${COLORS.dim}{${Object.keys(value).length} keys}${COLORS.reset}`;
+        }
+        return String(value);
+    }
+    defaultTimestamp() {
+        const now = new Date();
+        const h = String(now.getHours()).padStart(2, '0');
+        const m = String(now.getMinutes()).padStart(2, '0');
+        const s = String(now.getSeconds()).padStart(2, '0');
+        const ms = String(now.getMilliseconds()).padStart(3, '0');
+        return `${h}:${m}:${s}.${ms}`;
+    }
+    parseLevel(level) {
+        if (typeof level === 'number')
+            return level;
+        return LogLevel[level] ?? LogLevel.INFO;
+    }
+}
+exports.LoggerService = LoggerService;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { LoggerService, LogLevel, type LoggerConfig, type LogData } from './LoggerService';
+export { createCarnoLogger, CarnoLogger, createLogger, type LoggerPluginConfig } from './LoggerPlugin';

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = exports.CarnoLogger = exports.createCarnoLogger = exports.LogLevel = exports.LoggerService = void 0;
+var LoggerService_1 = require("./LoggerService");
+Object.defineProperty(exports, "LoggerService", { enumerable: true, get: function () { return LoggerService_1.LoggerService; } });
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return LoggerService_1.LogLevel; } });
+var LoggerPlugin_1 = require("./LoggerPlugin");
+Object.defineProperty(exports, "createCarnoLogger", { enumerable: true, get: function () { return LoggerPlugin_1.createCarnoLogger; } });
+Object.defineProperty(exports, "CarnoLogger", { enumerable: true, get: function () { return LoggerPlugin_1.CarnoLogger; } });
+Object.defineProperty(exports, "createLogger", { enumerable: true, get: function () { return LoggerPlugin_1.createLogger; } });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@carno.js/logger",
-    "version": "1.0.0",
+    "version": "1.0.3",
     "description": "High-performance async logger for carno.js",
     "main": "src/index.ts",
     "types": "src/index.ts",
@@ -22,5 +22,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "d2b000eeb352a03569b90d8eb2bf3557c00b741b"
-}
+    "gitHead": "61974ae937e0de61a207b37b97a01677fec69bcb"
+}