@athenna/logger 3.0.9 → 3.1.0

package/build/Helpers/ColorHelper.d.ts

@@ -0,0 +1,131 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { ChalkInstance } from 'chalk';
+export declare class ColorHelper {
+    /**
+     * Chalk instance.
+     */
+    static chalk: ChalkInstance;
+    /**
+     * Paint as bold.
+     */
+    static get bold(): ChalkInstance;
+    /**
+     * Paint as grey.
+     */
+    static get grey(): ChalkInstance;
+    /**
+     * Paint as purple.
+     */
+    static get purple(): ChalkInstance;
+    /**
+     * Paint as darkPurple.
+     */
+    static get darkPurple(): ChalkInstance;
+    /**
+     * Paint as yellow.
+     */
+    static get yellow(): ChalkInstance;
+    /**
+     * Paint as cyan.
+     */
+    static get cyan(): ChalkInstance;
+    /**
+     * Paint as white.
+     */
+    static get white(): ChalkInstance;
+    /**
+     * Paint as orange.
+     */
+    static get orange(): ChalkInstance;
+    /**
+     * Paint as green.
+     */
+    static get green(): ChalkInstance;
+    /**
+     * Paint as darkGreen.
+     */
+    static get darkGreen(): ChalkInstance;
+    /**
+     * Paint as red.
+     */
+    static get red(): ChalkInstance;
+    /**
+     * Paint as darkRed.
+     */
+    static get darkRed(): ChalkInstance;
+    /**
+     * Paint debugs.
+     */
+    static get trace(): ChalkInstance;
+    /**
+     * Paint debugs.
+     */
+    static get debug(): ChalkInstance;
+    /**
+     * Paint infos.
+     */
+    static get info(): ChalkInstance;
+    /**
+     * Paint success.
+     */
+    static get success(): ChalkInstance;
+    /**
+     * Paint warning.
+     */
+    static get warn(): ChalkInstance;
+    /**
+     * Paint error.
+     */
+    static get error(): ChalkInstance;
+    /**
+     * Paint fatal.
+     */
+    static get fatal(): ChalkInstance;
+    /**
+     * Paint http method.
+     */
+    static get GET(): ChalkInstance;
+    /**
+     * Paint http method.
+     */
+    static get HEAD(): ChalkInstance;
+    /**
+     * Paint http method.
+     */
+    static get PUT(): ChalkInstance;
+    /**
+     * Paint http method.
+     */
+    static get PATCH(): ChalkInstance;
+    /**
+     * Paint http method.
+     */
+    static get POST(): ChalkInstance;
+    /**
+     * Paint http method.
+     */
+    static get DELETE(): ChalkInstance;
+    /**
+     * Paint http method.
+     */
+    static get OPTIONS(): ChalkInstance;
+    /**
+     * Remove all colors and special chars of string.
+     */
+    static removeColors(value: string): string;
+    /**
+     * Paint by the http method.
+     */
+    static httpMethod(method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD'): ChalkInstance;
+    /**
+     * Applies the log engine to execute chalk methods.
+     */
+    static applyLogEngine(...args: string[]): any;
+}

package/build/Helpers/ColorHelper.js

@@ -0,0 +1,215 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { format } from 'node:util';
+import { Is } from '@athenna/common';
+import { Chalk } from 'chalk';
+export class ColorHelper {
+    /**
+     * Chalk instance.
+     */
+    static chalk = new Chalk();
+    /**
+     * Paint as bold.
+     */
+    static get bold() {
+        return ColorHelper.chalk.bold;
+    }
+    /**
+     * Paint as grey.
+     */
+    static get grey() {
+        return ColorHelper.chalk.hex('#505050');
+    }
+    /**
+     * Paint as purple.
+     */
+    static get purple() {
+        return ColorHelper.chalk.hex('#7628c8');
+    }
+    /**
+     * Paint as darkPurple.
+     */
+    static get darkPurple() {
+        return ColorHelper.chalk.hex('#501b86');
+    }
+    /**
+     * Paint as yellow.
+     */
+    static get yellow() {
+        return ColorHelper.chalk.hex('#ffe600');
+    }
+    /**
+     * Paint as cyan.
+     */
+    static get cyan() {
+        return ColorHelper.chalk.hex('#00ffff');
+    }
+    /**
+     * Paint as white.
+     */
+    static get white() {
+        return ColorHelper.chalk.hex('#ffffff');
+    }
+    /**
+     * Paint as orange.
+     */
+    static get orange() {
+        return ColorHelper.chalk.hex('#f18b0e');
+    }
+    /**
+     * Paint as green.
+     */
+    static get green() {
+        return ColorHelper.chalk.hex('#0ef12c');
+    }
+    /**
+     * Paint as darkGreen.
+     */
+    static get darkGreen() {
+        return ColorHelper.chalk.hex('#1cb70b');
+    }
+    /**
+     * Paint as red.
+     */
+    static get red() {
+        return ColorHelper.chalk.hex('#f10e0e');
+    }
+    /**
+     * Paint as darkRed.
+     */
+    static get darkRed() {
+        return ColorHelper.chalk.hex('#710909');
+    }
+    /**
+     * Paint debugs.
+     */
+    static get trace() {
+        return this.grey.bold;
+    }
+    /**
+     * Paint debugs.
+     */
+    static get debug() {
+        return this.purple.bold;
+    }
+    /**
+     * Paint infos.
+     */
+    static get info() {
+        return this.cyan;
+    }
+    /**
+     * Paint success.
+     */
+    static get success() {
+        return this.green;
+    }
+    /**
+     * Paint warning.
+     */
+    static get warn() {
+        return this.orange;
+    }
+    /**
+     * Paint error.
+     */
+    static get error() {
+        return this.red;
+    }
+    /**
+     * Paint fatal.
+     */
+    static get fatal() {
+        return ColorHelper.chalk.bgRed;
+    }
+    /**
+     * Paint http method.
+     */
+    static get GET() {
+        return this.purple.bold;
+    }
+    /**
+     * Paint http method.
+     */
+    static get HEAD() {
+        return this.cyan.bold;
+    }
+    /**
+     * Paint http method.
+     */
+    static get PUT() {
+        return this.orange.bold;
+    }
+    /**
+     * Paint http method.
+     */
+    static get PATCH() {
+        return this.yellow.bold;
+    }
+    /**
+     * Paint http method.
+     */
+    static get POST() {
+        return this.green.bold;
+    }
+    /**
+     * Paint http method.
+     */
+    static get DELETE() {
+        return this.red.bold;
+    }
+    /**
+     * Paint http method.
+     */
+    static get OPTIONS() {
+        return this.cyan.bold;
+    }
+    /**
+     * Remove all colors and special chars of string.
+     */
+    static removeColors(value) {
+        return ColorHelper.chalk.reset(value).replace(
+        // eslint-disable-next-line no-control-regex
+        /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+    }
+    /**
+     * Paint by the http method.
+     */
+    static httpMethod(method) {
+        return this[method];
+    }
+    /**
+     * Applies the log engine to execute chalk methods.
+     */
+    static applyLogEngine(...args) {
+        if (!Is.String(args[0])) {
+            return args[0];
+        }
+        let content = format(...args.filter(arg => arg !== undefined));
+        const matches = content.match(/\({(.*?)} ([\s\S]*?)\)/g);
+        if (!matches) {
+            return content;
+        }
+        matches.forEach(match => {
+            const [chalkMethodsInBrackets, chalkMethodsString] = match.match(/\{(.*?)\}/);
+            const message = match
+                .replace(chalkMethodsInBrackets, '')
+                .replace(/\s*\(\s*|\s*\)\s*/g, '');
+            const chalkMethodsArray = chalkMethodsString.replace(/\s/g, '').split(',');
+            let chalk = new Chalk();
+            chalkMethodsArray.forEach(chalkMethod => {
+                if (!chalk[chalkMethod])
+                    return;
+                chalk = chalk[chalkMethod];
+            });
+            content = content.replace(match, chalk(message));
+        });
+        return content;
+    }
+}

package/build/Helpers/FactoryHelper.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export declare class FactoryHelper {
+    /**
+     * Group the configuration values.
+     */
+    static groupConfigs(object: any, defaultValue: any): any;
+}

package/build/Helpers/FactoryHelper.js

@@ -0,0 +1,20 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { Options } from '@athenna/common';
+export class FactoryHelper {
+    /**
+     * Group the configuration values.
+     */
+    static groupConfigs(object, defaultValue) {
+        const formatter = object.formatter || defaultValue.formatter;
+        const formatterConfig = Options.create(object.formatterConfig, defaultValue.formatterConfig);
+        const driverConfig = Options.create(object, defaultValue);
+        return { ...driverConfig, formatter, formatterConfig };
+    }
+}

package/build/Logger/Logger.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { VanillaLogger } from '#src/Logger/VanillaLogger';
+export declare class Logger {
+    /**
+     * The drivers responsible for transporting the logs.
+     */
+    private drivers;
+    /**
+     * Runtime configurations to be used inside the Drivers and Formatters.
+     */
+    private runtimeConfigs;
+    constructor();
+    /**
+     * Set runtime configurations for drivers and
+     * formatters.
+     */
+    config(runtimeConfigs: any): this;
+    /**
+     * Change the log channel.
+     */
+    channel(...channels: string[]): this;
+    /**
+     * Call drivers to transport the log.
+     */
+    private log;
+    /**
+     * Creates a log of type trace in channel.
+     */
+    trace(...args: any[]): any | Promise<any>;
+    /**
+     * Creates a log of type debug in channel.
+     */
+    debug(...args: any[]): any | Promise<any>;
+    /**
+     * Creates a log of type info in channel.
+     */
+    info(...args: any[]): any | Promise<any>;
+    /**
+     * Creates a log of type success in channel.
+     */
+    success(...args: any[]): any | Promise<any>;
+    /**
+     * Creates a log of type warn in channel.
+     */
+    warn(...args: any[]): any | Promise<any>;
+    /**
+     * Creates a log of type error in channel.
+     */
+    error(...args: any[]): any | Promise<any>;
+    /**
+     * Creates a log of type fatal in channel.
+     */
+    fatal(...args: any[]): any | Promise<any>;
+    /**
+     * Get a new instance of any log driver
+     * with vanilla configurations. By default,
+     * vanilla logger will use the "console" driver
+     * and "none" formatter.
+     */
+    static getVanillaLogger(configs?: any): VanillaLogger;
+}

package/build/Logger/Logger.js

@@ -0,0 +1,105 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { Config } from '@athenna/config';
+import { ColorHelper } from '#src/Helpers/ColorHelper';
+import { VanillaLogger } from '#src/Logger/VanillaLogger';
+import { DriverFactory } from '#src/Factories/DriverFactory';
+export class Logger {
+    /**
+     * The drivers responsible for transporting the logs.
+     */
+    drivers = [];
+    /**
+     * Runtime configurations to be used inside the Drivers and Formatters.
+     */
+    runtimeConfigs = {};
+    constructor() {
+        if (!Config.exists(`logging.channels.${Config.get('logging.default')}`)) {
+            return this;
+        }
+        this.drivers.push(DriverFactory.fabricate('default', this.runtimeConfigs));
+    }
+    /**
+     * Set runtime configurations for drivers and
+     * formatters.
+     */
+    config(runtimeConfigs) {
+        this.runtimeConfigs = runtimeConfigs;
+        return this;
+    }
+    /**
+     * Change the log channel.
+     */
+    channel(...channels) {
+        this.drivers = [];
+        channels.forEach(c => {
+            this.drivers.push(DriverFactory.fabricate(c, this.runtimeConfigs));
+        });
+        return this;
+    }
+    /**
+     * Call drivers to transport the log.
+     */
+    async log(level, ...args) {
+        const message = ColorHelper.applyLogEngine(...args);
+        const promises = this.drivers.map((driver) => driver.transport(level, message));
+        return Promise.all(promises);
+    }
+    /**
+     * Creates a log of type trace in channel.
+     */
+    trace(...args) {
+        return this.log('trace', ...args);
+    }
+    /**
+     * Creates a log of type debug in channel.
+     */
+    debug(...args) {
+        return this.log('debug', ...args);
+    }
+    /**
+     * Creates a log of type info in channel.
+     */
+    info(...args) {
+        return this.log('info', ...args);
+    }
+    /**
+     * Creates a log of type success in channel.
+     */
+    success(...args) {
+        return this.log('success', ...args);
+    }
+    /**
+     * Creates a log of type warn in channel.
+     */
+    warn(...args) {
+        return this.log('warn', ...args);
+    }
+    /**
+     * Creates a log of type error in channel.
+     */
+    error(...args) {
+        return this.log('error', ...args);
+    }
+    /**
+     * Creates a log of type fatal in channel.
+     */
+    fatal(...args) {
+        return this.log('fatal', ...args);
+    }
+    /**
+     * Get a new instance of any log driver
+     * with vanilla configurations. By default,
+     * vanilla logger will use the "console" driver
+     * and "none" formatter.
+     */
+    static getVanillaLogger(configs = {}) {
+        return new VanillaLogger(configs);
+    }
+}

package/build/Logger/VanillaLogger.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export declare class VanillaLogger {
+    /**
+     * The driver responsible for transporting the logs.
+     */
+    drivers: any[];
+    constructor(configs: any);
+    /**
+     * Set runtime configurations for drivers and
+     * formatters.
+     */
+    config(): VanillaLogger;
+    /**
+     * Change the log channel.
+     */
+    channel(): VanillaLogger;
+    /**
+     * Call drivers to transport the log.
+     *
+     * @param {string} level
+     * @param {string} args
+     * @return {any | Promise<any>}
+     */
+    private log;
+    /**
+     * Creates a log of type trace in channel.
+     */
+    trace(...args: any[]): any | Promise<any>;
+    /**
+     * Creates a log of type debug in channel.
+     */
+    debug(...args: any[]): any | Promise<any>;
+    /**
+     * Creates a log of type info in channel.
+     */
+    info(...args: any[]): any | Promise<any>;
+    /**
+     * Creates a log of type success in channel.
+     */
+    success(...args: any[]): any | Promise<any>;
+    /**
+     * Creates a log of type warn in channel.
+     */
+    warn(...args: any[]): any | Promise<any>;
+    /**
+     * Creates a log of type error in channel.
+     */
+    error(...args: any[]): any | Promise<any>;
+    /**
+     * Creates a log of type fatal in channel.
+     */
+    fatal(...args: any[]): any | Promise<any>;
+}

package/build/Logger/VanillaLogger.js

@@ -0,0 +1,86 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { ColorHelper } from '#src/Helpers/ColorHelper';
+import { DriverFactory } from '#src/Factories/DriverFactory';
+export class VanillaLogger {
+    /**
+     * The driver responsible for transporting the logs.
+     */
+    drivers = [];
+    constructor(configs) {
+        this.drivers.push(DriverFactory.fabricateVanilla(configs));
+    }
+    /**
+     * Set runtime configurations for drivers and
+     * formatters.
+     */
+    config() {
+        return this;
+    }
+    /**
+     * Change the log channel.
+     */
+    channel() {
+        return this;
+    }
+    /**
+     * Call drivers to transport the log.
+     *
+     * @param {string} level
+     * @param {string} args
+     * @return {any | Promise<any>}
+     */
+    log(level, ...args) {
+        const message = ColorHelper.applyLogEngine(...args);
+        const promises = this.drivers.map((driver) => driver.transport(level, message));
+        return Promise.all(promises);
+    }
+    /**
+     * Creates a log of type trace in channel.
+     */
+    trace(...args) {
+        return this.log('trace', ...args);
+    }
+    /**
+     * Creates a log of type debug in channel.
+     */
+    debug(...args) {
+        return this.log('debug', ...args);
+    }
+    /**
+     * Creates a log of type info in channel.
+     */
+    info(...args) {
+        return this.log('info', ...args);
+    }
+    /**
+     * Creates a log of type success in channel.
+     */
+    success(...args) {
+        return this.log('success', ...args);
+    }
+    /**
+     * Creates a log of type warn in channel.
+     */
+    warn(...args) {
+        return this.log('warn', ...args);
+    }
+    /**
+     * Creates a log of type error in channel.
+     */
+    error(...args) {
+        return this.log('error', ...args);
+    }
+    /**
+     * Creates a log of type fatal in channel.
+     */
+    fatal(...args) {
+        return this.log('fatal', ...args);
+    }
+}

package/build/Providers/LoggerProvider.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { ServiceProvider } from '@athenna/ioc';
+export declare class LoggerProvider extends ServiceProvider {
+    register(): void;
+}