@carno.js/logger 1.0.0 → 1.0.2

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.2",
     "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": "963e66fb0ac345fbc71c8cc81c73c71eb160d0d5"
+}

package/src/LoggerPlugin.ts

@@ -1,56 +1,56 @@
-import { Carno } from '@carno.js/core/Carno';
-import { LoggerService, LoggerConfig, LogLevel } 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 function createCarnoLogger(config: LoggerPluginConfig = {}) {
-    const logger = new LoggerService(config);
-    return new Carno()
-        .services([
-            {
-                token: LoggerService,
-                useValue: logger
-            }
-        ])
-}
-
-export const CarnoLogger = createCarnoLogger();
-
-/**
- * Create a standalone logger (without Turbo).
- */
-export function createLogger(config: LoggerConfig = {}): LoggerService {
-    return new LoggerService(config);
-}
-
-// Re-export everything
-export { LoggerService, LogLevel } from './LoggerService';
-export type { LoggerConfig } from './LoggerService';
-export type { LogData } from './LoggerService';
+import { Carno } from '@carno.js/core/Carno';
+import { LoggerService, LoggerConfig, LogLevel } 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 function createCarnoLogger(config: LoggerPluginConfig = {}) {
+    const logger = new LoggerService(config);
+    return new Carno()
+        .services([
+            {
+                token: LoggerService,
+                useValue: logger
+            }
+        ])
+}
+
+export const CarnoLogger = createCarnoLogger();
+
+/**
+ * Create a standalone logger (without Turbo).
+ */
+export function createLogger(config: LoggerConfig = {}): LoggerService {
+    return new LoggerService(config);
+}
+
+// Re-export everything
+export { LoggerService, LogLevel } from './LoggerService';
+export type { LoggerConfig } from './LoggerService';
+export type { LogData } from './LoggerService';