@athenna/logger 3.0.9 → 3.1.0

package/build/Drivers/ConsoleDriver.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 { Driver } from '#src/Drivers/Driver';
+export declare class ConsoleDriver extends Driver {
+    transport(level: string, message: any): any;
+}

package/build/Drivers/ConsoleDriver.js

@@ -0,0 +1,19 @@
+/**
+ * @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 { Driver } from '#src/Drivers/Driver';
+export class ConsoleDriver extends Driver {
+    transport(level, message) {
+        if (!this.couldBeTransported(level)) {
+            return;
+        }
+        const formatted = this.format(level, message);
+        const streamType = this.getStreamTypeFor(level);
+        return process[streamType].write(`${formatted}\n`);
+    }
+}

package/build/Drivers/DiscordDriver.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 { Driver } from '#src/Drivers/Driver';
+export declare class DiscordDriver extends Driver {
+    transport(level: string, message: any): Promise<any>;
+}

package/build/Drivers/DiscordDriver.js

@@ -0,0 +1,22 @@
+/**
+ * @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 { HttpClient } from '@athenna/common';
+import { Driver } from '#src/Drivers/Driver';
+export class DiscordDriver extends Driver {
+    async transport(level, message) {
+        if (!this.couldBeTransported(level)) {
+            return;
+        }
+        const formatted = this.format(level, message, true);
+        return HttpClient.builder(true).post(this.configs.url, {
+            username: this.configs.username,
+            content: formatted,
+        });
+    }
+}

package/build/Drivers/Driver.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @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 abstract class Driver {
+    /**
+     * Holds the configuration object itself.
+     */
+    configs: any;
+    /**
+     * Holds the configuration object of driver,
+     */
+    driverConfig: any;
+    /**
+     * Holds the formatter string value.
+     */
+    formatter: string;
+    /**
+     * Holds the configuration object of formatter.
+     */
+    formatterConfig: any;
+    /**
+     * The max log level that this driver can transport.
+     */
+    level: string;
+    /**
+     * The log level order to check if log could
+     * be transported or not.
+     */
+    levelOrder: string[];
+    constructor(configs?: any);
+    /**
+     * Transport the log.
+     */
+    abstract transport(level: string, message: any): any;
+    /**
+     * Check if message could be transported.
+     */
+    couldBeTransported(level: string): boolean;
+    /**
+     * Call formatter factory to format the message.
+     */
+    format(level: string, message: any, clean?: boolean): string;
+    /**
+     * Get the stream type for level.
+     */
+    getStreamTypeFor(level: string): string;
+}

package/build/Drivers/Driver.js

@@ -0,0 +1,85 @@
+/**
+ * @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 { Json } from '@athenna/common';
+import { FormatterFactory } from '#src/Factories/FormatterFactory';
+export class Driver {
+    /**
+     * Holds the configuration object itself.
+     */
+    configs = {};
+    /**
+     * Holds the configuration object of driver,
+     */
+    driverConfig = {};
+    /**
+     * Holds the formatter string value.
+     */
+    formatter = 'none';
+    /**
+     * Holds the configuration object of formatter.
+     */
+    formatterConfig = {};
+    /**
+     * The max log level that this driver can transport.
+     */
+    level = 'info';
+    /**
+     * The log level order to check if log could
+     * be transported or not.
+     */
+    levelOrder = [
+        'trace',
+        'debug',
+        'info',
+        'success',
+        'warn',
+        'error',
+        'fatal',
+    ];
+    constructor(configs = {}) {
+        this.configs = configs;
+        const json = Json.copy(configs);
+        delete json.formatter;
+        delete json.formatterConfig;
+        this.driverConfig = json;
+        this.level = json.level || 'info';
+        this.formatter = configs.formatter || 'none';
+        this.formatterConfig = configs.formatterConfig || {};
+    }
+    /**
+     * Check if message could be transported.
+     */
+    couldBeTransported(level) {
+        const levelIndex = this.levelOrder.indexOf(level);
+        const maxLevelIndex = this.levelOrder.indexOf(this.level);
+        return levelIndex >= maxLevelIndex;
+    }
+    /**
+     * Call formatter factory to format the message.
+     */
+    format(level, message, clean = false) {
+        const formatterConfig = { level, clean, ...this.formatterConfig };
+        return FormatterFactory.fabricate(this.formatter)
+            .config(formatterConfig)
+            .format(message);
+    }
+    /**
+     * Get the stream type for level.
+     */
+    getStreamTypeFor(level) {
+        if (this.driverConfig.streamType) {
+            return this.driverConfig.streamType;
+        }
+        let streamType = 'stdout';
+        if (level === 'error' || level === 'fatal') {
+            streamType = 'stderr';
+        }
+        return streamType;
+    }
+}

package/build/Drivers/FileDriver.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 { Driver } from '#src/Drivers/Driver';
+export declare class FileDriver extends Driver {
+    transport(level: string, message: any): Promise<any>;
+}

package/build/Drivers/FileDriver.js

@@ -0,0 +1,24 @@
+/**
+ * @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 { File } from '@athenna/common';
+import { Driver } from '#src/Drivers/Driver';
+export class FileDriver extends Driver {
+    async transport(level, message) {
+        if (!this.couldBeTransported(level)) {
+            return;
+        }
+        const filePath = this.driverConfig.filePath;
+        const formatted = this.format(level, message, true);
+        const buffer = Buffer.from(`${formatted}\n`, 'utf-8');
+        if (await File.exists(filePath)) {
+            return new File(filePath).append(buffer);
+        }
+        return new File(filePath, buffer).load();
+    }
+}

package/build/Drivers/NullDriver.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 { Driver } from '#src/Drivers/Driver';
+export declare class NullDriver extends Driver {
+    transport(): any;
+}

package/build/Drivers/NullDriver.js

@@ -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.
+ */
+import { Driver } from '#src/Drivers/Driver';
+export class NullDriver extends Driver {
+    transport() {
+        return null;
+    }
+}

package/build/Drivers/SlackDriver.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 { Driver } from '#src/Drivers/Driver';
+export declare class SlackDriver extends Driver {
+    transport(level: string, message: any): Promise<any>;
+}

package/build/Drivers/SlackDriver.js

@@ -0,0 +1,19 @@
+/**
+ * @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 { HttpClient } from '@athenna/common';
+import { Driver } from '#src/Drivers/Driver';
+export class SlackDriver extends Driver {
+    async transport(level, message) {
+        if (!this.couldBeTransported(level)) {
+            return;
+        }
+        const formatted = this.format(level, message, true);
+        return HttpClient.builder(true).post(this.configs.url, { text: formatted });
+    }
+}

package/build/Drivers/StackDriver.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 { Driver } from '#src/Drivers/Driver';
+export declare class StackDriver extends Driver {
+    transport(level: string, message: any): Promise<any>;
+}

package/build/Drivers/StackDriver.js

@@ -0,0 +1,19 @@
+/**
+ * @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 { Json } from '@athenna/common';
+import { Driver } from '#src/Drivers/Driver';
+import { DriverFactory } from '#src/Factories/DriverFactory';
+export class StackDriver extends Driver {
+    transport(level, message) {
+        const configs = Json.copy(this.configs);
+        delete configs.driver;
+        delete configs.channels;
+        return Promise.all(this.driverConfig.channels.map(c => DriverFactory.fabricate(c, configs).transport(level, message)));
+    }
+}

package/build/Drivers/TelegramDriver.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 { Driver } from '#src/Drivers/Driver';
+export declare class TelegramDriver extends Driver {
+    transport(level: string, message: any): Promise<any>;
+}

package/build/Drivers/TelegramDriver.js

@@ -0,0 +1,21 @@
+/**
+ * @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 { Telegraf } from 'telegraf';
+import { Driver } from '#src/Drivers/Driver';
+export class TelegramDriver extends Driver {
+    async transport(level, message) {
+        if (!this.couldBeTransported(level)) {
+            return;
+        }
+        const formatted = this.format(level, message, true);
+        return new Telegraf(this.driverConfig.token).telegram.sendMessage(this.driverConfig.chatId, formatted, {
+            parse_mode: this.driverConfig.parseMode,
+        });
+    }
+}

package/build/Exceptions/DriverExistException.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 { Exception } from '@athenna/common';
+export declare class DriverExistException extends Exception {
+    constructor(driverName: string);
+}

package/build/Exceptions/DriverExistException.js

@@ -0,0 +1,21 @@
+/**
+ * @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 { Exception } from '@athenna/common';
+import { DriverFactory } from '#src/Factories/DriverFactory';
+export class DriverExistException extends Exception {
+    constructor(driverName) {
+        const availableDrivers = DriverFactory.availableDrivers().join(', ');
+        super({
+            status: 500,
+            code: 'E_EXIST_DRIVER',
+            message: `The driver ${driverName} already exists in DriverFactory.`,
+            help: `Available drivers are: ${availableDrivers}. The name ${driverName} is already in use inside DriverFactory. Try using a different name for your driver implementation.`,
+        });
+    }
+}

package/{src/Facades/Log.js → build/Exceptions/FormatterExistException.d.ts}

@@ -6,12 +6,7 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-
-import { Facade } from '@athenna/ioc'
-
-/**
- * Log facade.
- *
- * @type {typeof Facade & import('#src/index').Logger}
- */
-export const Log = Facade.createFor('Athenna/Core/Logger')
+import { Exception } from '@athenna/common';
+export declare class FormatterExistException extends Exception {
+    constructor(formatterName: string);
+}

package/build/Exceptions/FormatterExistException.js

@@ -0,0 +1,21 @@
+/**
+ * @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 { Exception } from '@athenna/common';
+import { FormatterFactory } from '#src/Factories/FormatterFactory';
+export class FormatterExistException extends Exception {
+    constructor(formatterName) {
+        const availableFormatters = FormatterFactory.availableFormatters().join(', ');
+        super({
+            status: 500,
+            code: 'E_EXIST_FORMATTER',
+            message: `The formatter ${formatterName} already exists in FormatterFactory.`,
+            help: `Available formatters are: ${availableFormatters}. The name ${formatterName} is already in use inside FormatterFactory. Try using a different name for your formatter implementation.`,
+        });
+    }
+}

package/build/Exceptions/NotFoundDriverException.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 { Exception } from '@athenna/common';
+export declare class NotFoundDriverException extends Exception {
+    constructor(driverName: string);
+}

package/build/Exceptions/NotFoundDriverException.js

@@ -0,0 +1,21 @@
+/**
+ * @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 { Exception, Path } from '@athenna/common';
+import { DriverFactory } from '#src/Factories/DriverFactory';
+export class NotFoundDriverException extends Exception {
+    constructor(driverName) {
+        const availableDrivers = DriverFactory.availableDrivers().join(', ');
+        super({
+            status: 500,
+            code: 'E_NOT_FOUND',
+            message: `The driver ${driverName} has not been found.`,
+            help: `Available drivers are: ${availableDrivers}. Look into your config/logger.${Path.ext()} file if ${driverName} driver is implemented by logger. Or create ${driverName} driver implementation using DriverFactory.createDriver("${driverName}", ...) method.`,
+        });
+    }
+}

package/build/Exceptions/NotFoundFormatterException.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 { Exception } from '@athenna/common';
+export declare class NotFoundFormatterException extends Exception {
+    constructor(formatterName: string);
+}

package/build/Exceptions/NotFoundFormatterException.js

@@ -0,0 +1,21 @@
+/**
+ * @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 { Exception } from '@athenna/common';
+import { FormatterFactory } from '#src/Factories/FormatterFactory';
+export class NotFoundFormatterException extends Exception {
+    constructor(formatterName) {
+        const availableDrivers = FormatterFactory.availableFormatters().join(', ');
+        super({
+            status: 500,
+            code: 'E_NOT_FOUND',
+            message: `The formatter ${formatterName} has not been found.`,
+            help: `Available formatters are: ${availableDrivers}. Look into your config/logger file if ${formatterName} formatter is implemented by logger. Or create ${formatterName} formatter implementation using FormatterFactory.createFormatter("${formatterName}", ...) method.`,
+        });
+    }
+}

package/build/Exceptions/NotImplementedConfigException.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 { Exception } from '@athenna/common';
+export declare class NotImplementedConfigException extends Exception {
+    constructor(channelName: string, channels?: any[]);
+}

package/build/Exceptions/NotImplementedConfigException.js

@@ -0,0 +1,28 @@
+/**
+ * @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 { Path, Exception } from '@athenna/common';
+export class NotImplementedConfigException extends Exception {
+    constructor(channelName, channels) {
+        let help = '';
+        if (channels && channels.length) {
+            const availableConfigs = Object.keys(channels).join(', ');
+            help += `Available configurations are: ${availableConfigs}.`;
+        }
+        else {
+            help += `The "Config.get('logging.channels')" is empty, maybe your configuration files are not loaded?`;
+        }
+        help += ` Create your configuration inside channels object to use it. Or load your configuration files using "Config.safeLoad(Path.config('logging.${Path.ext()}'))`;
+        super({
+            status: 500,
+            code: 'E_NOT_IMPLEMENTED_CONFIG_ERROR',
+            message: `Channel ${channelName} is not configured inside logging.channels object from config/logging.${Path.ext()} file.`,
+            help,
+        });
+    }
+}

package/build/Facades/Log.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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 { Logger } from '#src/Logger/Logger';
+export declare const Log: import("@athenna/ioc").FacadeType<Logger>;

package/build/Facades/Log.js

@@ -0,0 +1,10 @@
+/**
+ * @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 { Facade } from '@athenna/ioc';
+export const Log = Facade.createFor('Athenna/Core/Logger');

package/build/Factories/DriverFactory.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @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 { Driver } from '#src/Drivers/Driver';
+export declare class DriverFactory {
+    /**
+     * Drivers of DriverFactory.
+     */
+    static drivers: Map<string, {
+        Driver: any;
+    }>;
+    /**
+     * Return an array with all available drivers.
+     */
+    static availableDrivers(): any[];
+    /**
+     * Fabricate a new instance of a driver based on
+     * channel configurations.
+     */
+    static fabricate(channelName: string, configs?: any): Driver;
+    /**
+     * Fabricate a new instance of a driver with vanilla
+     * configurations.
+     */
+    static fabricateVanilla(configs?: any): Driver;
+    /**
+     * Creates a new driver implementation.
+     */
+    static createDriver(name: string, driver: typeof Driver): void;
+    /**
+     * Get all the configuration of a channel.
+     */
+    static getChannelConfig(channelName: string): any;
+}