@athenna/logger 3.1.1 → 3.1.3

package/build/Constants/VanillaChannels.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+/**
+ * Athenna default vanilla channels. This configurations
+ * will be used by the "channelOrVanilla" method. If the
+ * configuration does not exist, than the vanilla will be set.
+ */
+export declare const VANILLA_CHANNELS: {
+    default: {
+        driver: string;
+        channels: string[];
+    };
+    stack: {
+        driver: string;
+        channels: string[];
+    };
+    discard: {
+        driver: string;
+    };
+    console: {
+        level: string;
+        formatter: string;
+        driver: string;
+    };
+    exception: {
+        level: string;
+        formatter: string;
+        driver: string;
+        streamType: string;
+    };
+    application: {
+        level: string;
+        driver: string;
+        formatter: string;
+    };
+};

package/build/Constants/VanillaChannels.js

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+/**
+ * Athenna default vanilla channels. This configurations
+ * will be used by the "channelOrVanilla" method. If the
+ * configuration does not exist, than the vanilla will be set.
+ */
+export const VANILLA_CHANNELS = {
+    default: {
+        driver: 'stack',
+        channels: ['application'],
+    },
+    stack: {
+        driver: 'stack',
+        channels: ['application'],
+    },
+    discard: {
+        driver: 'null',
+    },
+    console: {
+        level: 'trace',
+        formatter: 'cli',
+        driver: 'console',
+    },
+    exception: {
+        level: 'trace',
+        formatter: 'none',
+        driver: 'console',
+        streamType: 'stderr',
+    },
+    application: {
+        level: 'trace',
+        driver: 'console',
+        formatter: 'simple',
+    },
+};

package/build/Exceptions/NotImplementedConfigException.d.ts

@@ -8,5 +8,5 @@
  */
 import { Exception } from '@athenna/common';
 export declare class NotImplementedConfigException extends Exception {
-    constructor(channelName: string, channels?: any[]);
+    constructor(channelName: string);
 }

package/build/Exceptions/NotImplementedConfigException.js

@@ -6,11 +6,12 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import { Path, Exception } from '@athenna/common';
+import { Path, Exception, Is } from '@athenna/common';
 export class NotImplementedConfigException extends Exception {
-    constructor(channelName, channels) {
+    constructor(channelName) {
         let help = '';
-        if (channels && channels.length) {
+        const channels = Config.get('logging.channels');
+        if (channels && !Is.Empty(channels)) {
             const availableConfigs = Object.keys(channels).join(', ');
             help += `Available configurations are: ${availableConfigs}.`;
         }

package/build/Factories/DriverFactory.js

@@ -79,7 +79,7 @@ export class DriverFactory {
      */
     static getChannelConfig(channelName) {
         if (channelName === 'default') {
-            channelName = Config.get('logging.default') || channelName;
+            channelName = Config.get('logging.default', channelName);
         }
         const channelConfig = Config.get(`logging.channels.${channelName}`);
         if (!channelConfig) {

package/build/Formatters/Formatter.js

@@ -112,7 +112,7 @@ export class Formatter {
     cliLevel() {
         const level = this.configs.level;
         if (!Color[level]) {
-            return level;
+            return Color.bold(`[  ${level}  ]`);
         }
         return Color[level].bold(`[  ${level}  ]`);
     }
@@ -122,7 +122,7 @@ export class Formatter {
     simpleLevel() {
         const level = this.configs.level;
         if (!Color[level]) {
-            return level;
+            return Color.bold(`[${level.toUpperCase()}]`);
         }
         return Color[level].bold(`[${level.toUpperCase()}]`);
     }

package/build/Formatters/NoneFormatter.js

@@ -9,6 +9,6 @@
 import { Formatter } from '#src/Formatters/Formatter';
 export class NoneFormatter extends Formatter {
     format(message) {
-        return this.clean(this.toString(message));
+        return this.clean(this.applyColorsByChalk(this.toString(message)));
     }
 }

package/build/Logger/Logger.d.ts

@@ -6,7 +6,6 @@
  * 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.
@@ -17,19 +16,38 @@ export declare class Logger {
      */
     private runtimeConfigs;
     constructor();
+    /**
+     * Create a new standalone logger instance. Very
+     * useful to create new loggers without changing the
+     * channels that are already defined in the main instance.
+     */
+    static standalone(...configs: any[]): Logger;
     /**
      * Set runtime configurations for drivers and
      * formatters.
      */
-    config(runtimeConfigs: any): this;
+    config(runtimeConfigs: any): Logger;
     /**
      * Change the log channel.
      */
-    channel(...channels: string[]): this;
+    channel(...channels: string[]): Logger;
     /**
-     * Call drivers to transport the log.
+     * Change the log drivers using vanilla configurations.
+     * This method does not depend in Athenna configuration
+     * files to be executed.
      */
-    private log;
+    vanilla(...configs: any[]): Logger;
+    /**
+     * Verify if channel configuration exists. If not, Athenna will
+     * use the default vanilla configurations as drivers.
+     */
+    channelOrVanilla(channel: string, configs?: {}): Logger;
+    /**
+     * Create a new standalone logger instance. Very
+     * useful to create new loggers without changing the
+     * channels that are already defined in the main instance.
+     */
+    standalone(...configs: any[]): Logger;
     /**
      * Creates a log of type trace in channel.
      */
@@ -59,10 +77,7 @@ export declare class Logger {
      */
     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.
+     * Call drivers to transport the log.
      */
-    static getVanillaLogger(configs?: any): VanillaLogger;
+    private log;
 }

package/build/Logger/Logger.js

@@ -8,8 +8,8 @@
  */
 import { Color } from '@athenna/common';
 import { Config } from '@athenna/config';
-import { VanillaLogger } from '#src/Logger/VanillaLogger';
 import { DriverFactory } from '#src/Factories/DriverFactory';
+import { VANILLA_CHANNELS } from '../Constants/VanillaChannels.js';
 export class Logger {
     /**
      * The drivers responsible for transporting the logs.
@@ -20,10 +20,17 @@ export class Logger {
      */
     runtimeConfigs = {};
     constructor() {
-        if (!Config.exists(`logging.channels.${Config.get('logging.default')}`)) {
-            return this;
-        }
-        this.drivers.push(DriverFactory.fabricate('default', this.runtimeConfigs));
+        this.channelOrVanilla(Config.get('logging.default'));
+    }
+    /**
+     * Create a new standalone logger instance. Very
+     * useful to create new loggers without changing the
+     * channels that are already defined in the main instance.
+     */
+    static standalone(...configs) {
+        const logger = new Logger();
+        logger.vanilla(...configs);
+        return logger;
     }
     /**
      * Set runtime configurations for drivers and
@@ -38,18 +45,50 @@ export class Logger {
      */
     channel(...channels) {
         this.drivers = [];
-        channels.forEach(c => {
-            this.drivers.push(DriverFactory.fabricate(c, this.runtimeConfigs));
+        channels.forEach(channel => {
+            this.drivers.push(DriverFactory.fabricate(channel, this.runtimeConfigs));
         });
         return this;
     }
     /**
-     * Call drivers to transport the log.
+     * Change the log drivers using vanilla configurations.
+     * This method does not depend in Athenna configuration
+     * files to be executed.
      */
-    async log(level, ...args) {
-        const message = Color.apply(...args);
-        const promises = this.drivers.map((driver) => driver.transport(level, message));
-        return Promise.all(promises);
+    vanilla(...configs) {
+        this.drivers = [];
+        if (!configs.length) {
+            this.drivers.push(DriverFactory.fabricateVanilla());
+            return this;
+        }
+        configs.forEach(config => {
+            this.drivers.push(DriverFactory.fabricateVanilla(config));
+        });
+        return this;
+    }
+    /**
+     * Verify if channel configuration exists. If not, Athenna will
+     * use the default vanilla configurations as drivers.
+     */
+    channelOrVanilla(channel, configs = {}) {
+        if (channel === 'default') {
+            channel = Config.get(`logging.channels.${Config.get('logging.default')}`, 'default');
+        }
+        if (Config.exists(`logging.channels.${channel}`)) {
+            return this.channel(channel);
+        }
+        return this.vanilla({
+            ...VANILLA_CHANNELS[channel],
+            ...configs,
+        });
+    }
+    /**
+     * Create a new standalone logger instance. Very
+     * useful to create new loggers without changing the
+     * channels that are already defined in the main instance.
+     */
+    standalone(...configs) {
+        return Logger.standalone(...configs);
     }
     /**
      * Creates a log of type trace in channel.
@@ -94,12 +133,11 @@ export class Logger {
         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.
+     * Call drivers to transport the log.
      */
-    static getVanillaLogger(configs = {}) {
-        return new VanillaLogger(configs);
+    async log(level, ...args) {
+        const message = Color.apply(...args);
+        const promises = this.drivers.map((driver) => driver.transport(level, message));
+        return Promise.all(promises);
     }
 }

package/build/index.d.ts

@@ -10,7 +10,6 @@ export * from './Facades/Log.js';
 export * from './Logger/Logger.js';
 export * from './Drivers/Driver.js';
 export * from './Formatters/Formatter.js';
-export * from './Logger/VanillaLogger.js';
 export * from './Helpers/FactoryHelper.js';
 export * from './Factories/DriverFactory.js';
 export * from './Providers/LoggerProvider.js';

package/build/index.js

@@ -10,7 +10,6 @@ export * from './Facades/Log.js';
 export * from './Logger/Logger.js';
 export * from './Drivers/Driver.js';
 export * from './Formatters/Formatter.js';
-export * from './Logger/VanillaLogger.js';
 export * from './Helpers/FactoryHelper.js';
 export * from './Factories/DriverFactory.js';
 export * from './Providers/LoggerProvider.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/logger",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "description": "The Athenna logging solution. Log in stdout, files and buckets.",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",

package/build/Logger/VanillaLogger.d.ts

@@ -1,65 +0,0 @@
-/**
- * @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);
-    /**
-     * Log a simple log message without using the log driver
-     * but using the Color engine.
-     */
-    simple(...args: any[]): void;
-    /**
-     * 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

@@ -1,93 +0,0 @@
-/**
- * @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 { Color } from '@athenna/common';
-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));
-    }
-    /**
-     * Log a simple log message without using the log driver
-     * but using the Color engine.
-     */
-    simple(...args) {
-        process.stdout.write(Color.apply(...args).concat('\n'));
-    }
-    /**
-     * 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 = Color.apply(...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);
-    }
-}