@athenna/logger 1.1.5 → 1.1.8

package/index.d.ts

@@ -7,6 +7,7 @@
  * file that was distributed with this source code.
  */
 export * from './src/Logger';
+export * from './src/Facades/Log';
 export * from './src/Utils/Color';
 export * from './src/Contracts/DriverContract';
 export * from './src/Contracts/FormatterContract';

package/index.js

@@ -19,6 +19,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./src/Logger"), exports);
+__exportStar(require("./src/Facades/Log"), exports);
 __exportStar(require("./src/Utils/Color"), exports);
 __exportStar(require("./src/Contracts/DriverContract"), exports);
 __exportStar(require("./src/Contracts/FormatterContract"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/logger",
-  "version": "1.1.5",
+  "version": "1.1.8",
   "description": "",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",
@@ -122,6 +122,7 @@
       "dot-notation": "off",
       "camelcase": "off",
       "no-undef": "off",
+      "no-useless-escape": "off",
       "@typescript-eslint/no-var-requires": "off",
       "no-useless-constructor": "off",
       "@typescript-eslint/no-useless-constructor": "off",
@@ -153,10 +154,14 @@
     }
   },
   "dependencies": {
-    "@athenna/ioc": "1.1.2",
+    "@athenna/ioc": "1.1.3",
     "@secjs/utils": "1.8.3",
+    "axios": "0.26.1",
     "chalk": "4.1.1",
+    "pino": "7.10.0",
+    "pino-pretty": "7.6.1",
     "reflect-metadata": "0.1.13",
+    "telegraf": "4.7.0",
     "tscpaths": "0.0.9"
   }
 }

package/src/Contracts/DefaultDriverConfigs.d.ts

@@ -0,0 +1,4 @@
+export interface DefaultDriverConfigs {
+    formatter: string;
+    formatterConfig: any;
+}

package/src/Contracts/DefaultDriverConfigs.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/Contracts/DriverContract.d.ts

@@ -6,6 +6,8 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
+import { DefaultDriverConfigs } from './DefaultDriverConfigs';
 export interface DriverContract {
+    configs?: DefaultDriverConfigs | any;
     transport(message: string, options?: any): void | Promise<void>;
 }

package/src/Drivers/ConsoleDriver.d.ts

@@ -6,20 +6,14 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import { Color } from '../Utils/Color';
 import { DriverContract } from '../Contracts/DriverContract';
 export interface ConsoleDriverOpts {
-    color: Color;
-    level: string;
-    context: string;
-    formatter: string;
-    streamType: string;
-    formatterConfig: any;
+    streamType?: 'stdout' | 'stderr';
+    formatter?: any;
+    formatterConfig?: any;
 }
 export declare class ConsoleDriver implements DriverContract {
-    private readonly _formatter;
-    private readonly _streamType;
-    private readonly _formatterConfig;
+    configs: Required<ConsoleDriverOpts>;
     constructor(channel: string, configs?: any);
     transport(message: string, options?: ConsoleDriverOpts): void;
 }

package/src/Drivers/ConsoleDriver.js

@@ -10,22 +10,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleDriver = void 0;
 const utils_1 = require("@secjs/utils");
+const groupConfigs_1 = require("../Utils/groupConfigs");
 const FormatterFactory_1 = require("../Factories/FormatterFactory");
 class ConsoleDriver {
     constructor(channel, configs = {}) {
         const channelConfig = utils_1.Config.get(`logging.channels.${channel}`);
-        this._formatter = configs.formatter || channelConfig.formatter;
-        this._streamType = configs.streamType || channelConfig.streamType;
-        this._formatterConfig = Object.assign({}, channelConfig.formatterConfig, configs.formatterConfig);
+        this.configs = groupConfigs_1.groupConfigs(configs, channelConfig);
     }
-    transport(message, options) {
-        options = Object.assign({}, {
-            formatter: this._formatter,
-            streamType: this._streamType,
-        }, options);
-        const formatterOptions = Object.assign({}, this._formatterConfig, options.formatterConfig);
-        message = FormatterFactory_1.FormatterFactory.fabricate(options.formatter).format(message, formatterOptions);
-        process[options.streamType].write(`${message}\n`);
+    transport(message, options = {}) {
+        const configs = groupConfigs_1.groupConfigs(options, this.configs);
+        message = FormatterFactory_1.FormatterFactory.fabricate(configs.formatter).format(message, configs.formatterConfig);
+        process[configs.streamType].write(`${message}\n`);
     }
 }
 exports.ConsoleDriver = ConsoleDriver;

package/src/Drivers/DebugDriver.d.ts

@@ -6,20 +6,14 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import { Color } from '../Utils/Color';
 import { DriverContract } from '../Contracts/DriverContract';
 export interface DebugDriverOpts {
-    color: Color;
-    level: string;
-    context: string;
-    formatter: string;
-    namespace: string;
-    formatterConfig: any;
+    namespace?: string;
+    formatter?: any;
+    formatterConfig?: any;
 }
 export declare class DebugDriver implements DriverContract {
-    private readonly _formatter;
-    private readonly _namespace;
-    private readonly _formatterConfig;
+    configs: Required<DebugDriverOpts>;
     constructor(channel: string, configs?: any);
     transport(message: string, options?: DebugDriverOpts): void;
 }

package/src/Drivers/DebugDriver.js

@@ -11,22 +11,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DebugDriver = void 0;
 const debug_1 = require("debug");
 const utils_1 = require("@secjs/utils");
+const groupConfigs_1 = require("../Utils/groupConfigs");
 const FormatterFactory_1 = require("../Factories/FormatterFactory");
 class DebugDriver {
     constructor(channel, configs = {}) {
         const channelConfig = utils_1.Config.get(`logging.channels.${channel}`);
-        this._formatter = configs.formatter || channelConfig.formatter;
-        this._namespace = configs.namespace || channelConfig.namespace;
-        this._formatterConfig = Object.assign({}, channelConfig.formatterConfig, configs.formatterConfig);
+        this.configs = groupConfigs_1.groupConfigs(configs, channelConfig);
     }
-    transport(message, options) {
-        options = Object.assign({}, {
-            formatter: this._formatter,
-            namespace: this._namespace,
-        }, options);
-        const formatterOptions = Object.assign({}, this._formatterConfig, options.formatterConfig);
-        message = FormatterFactory_1.FormatterFactory.fabricate(options.formatter).format(message, formatterOptions);
-        debug_1.debug(options.namespace)(message);
+    transport(message, options = {}) {
+        const configs = groupConfigs_1.groupConfigs(options, this.configs);
+        message = FormatterFactory_1.FormatterFactory.fabricate(configs.formatter).format(message, configs.formatterConfig);
+        debug_1.debug(configs.namespace)(message);
     }
 }
 exports.DebugDriver = DebugDriver;

package/src/Drivers/DiscordDriver.d.ts

@@ -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 { DriverContract } from '../Contracts/DriverContract';
+export interface DiscordDriverOpts {
+    url?: string;
+    username?: string;
+    formatter?: any;
+    formatterConfig?: any;
+}
+export declare class DiscordDriver implements DriverContract {
+    configs: Required<DiscordDriverOpts>;
+    constructor(channel: string, configs?: any);
+    transport(message: string, options?: DiscordDriverOpts): Promise<void>;
+}

package/src/Drivers/DiscordDriver.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * @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.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscordDriver = void 0;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("@secjs/utils");
+const Color_1 = require("../Utils/Color");
+const groupConfigs_1 = require("../Utils/groupConfigs");
+const FormatterFactory_1 = require("../Factories/FormatterFactory");
+class DiscordDriver {
+    constructor(channel, configs = {}) {
+        const channelConfig = utils_1.Config.get(`logging.channels.${channel}`);
+        this.configs = groupConfigs_1.groupConfigs(configs, channelConfig);
+    }
+    async transport(message, options = {}) {
+        const configs = groupConfigs_1.groupConfigs(options, this.configs);
+        message = FormatterFactory_1.FormatterFactory.fabricate(configs.formatter).format(message, configs.formatterConfig);
+        await axios_1.default.post(configs.url, {
+            username: configs.username,
+            content: Color_1.Color.removeColors(message),
+        });
+    }
+}
+exports.DiscordDriver = DiscordDriver;

package/src/Drivers/FileDriver.d.ts

@@ -8,16 +8,12 @@
  */
 import { DriverContract } from '../Contracts/DriverContract';
 export interface FileDriverOpts {
-    level: string;
-    context: string;
-    formatter: string;
-    filePath: string;
-    formatterConfig: any;
+    filePath?: string;
+    formatter?: any;
+    formatterConfig?: any;
 }
 export declare class FileDriver implements DriverContract {
-    private readonly _filePath;
-    private readonly _formatter;
-    private readonly _formatterConfig;
+    configs: Required<FileDriverOpts>;
     constructor(channel: string, configs?: any);
     transport(message: string, options?: FileDriverOpts): Promise<void>;
 }

package/src/Drivers/FileDriver.js

@@ -12,27 +12,22 @@ exports.FileDriver = void 0;
 const path_1 = require("path");
 const utils_1 = require("@secjs/utils");
 const Color_1 = require("../Utils/Color");
+const groupConfigs_1 = require("../Utils/groupConfigs");
 const fs_1 = require("fs");
 const FormatterFactory_1 = require("../Factories/FormatterFactory");
 class FileDriver {
     constructor(channel, configs = {}) {
         const channelConfig = utils_1.Config.get(`logging.channels.${channel}`);
-        this._filePath = configs.filePath || channelConfig.filePath;
-        this._formatter = configs.formatter || channelConfig.formatter;
-        this._formatterConfig = Object.assign({}, channelConfig.formatterConfig, configs.formatterConfig);
+        this.configs = groupConfigs_1.groupConfigs(configs, channelConfig);
     }
-    async transport(message, options) {
-        options = Object.assign({}, {
-            filePath: this._filePath,
-            formatter: this._formatter,
-        }, options);
-        const filePath = options.filePath;
+    async transport(message, options = {}) {
+        const configs = groupConfigs_1.groupConfigs(options, this.configs);
+        const filePath = configs.filePath;
         const { dir } = path_1.parse(filePath);
         if (!fs_1.existsSync(dir)) {
             fs_1.mkdirSync(dir, { recursive: true });
         }
-        const formatterOptions = Object.assign({}, this._formatterConfig, options.formatterConfig);
-        message = FormatterFactory_1.FormatterFactory.fabricate(options.formatter).format(message, formatterOptions);
+        message = FormatterFactory_1.FormatterFactory.fabricate(configs.formatter).format(message, configs.formatterConfig);
         return new Promise((resolve, reject) => {
             const stream = fs_1.createWriteStream(filePath, { flags: 'a' });
             stream.write(`${Color_1.Color.removeColors(message)}` + '\n');

package/src/Drivers/NullDriver.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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 { DriverContract } from '../Contracts/DriverContract';
+export declare class NullDriver implements DriverContract {
+    constructor(_channel: string, _configs?: any);
+    transport(_message: string, _options?: any): void;
+}

package/src/Drivers/NullDriver.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullDriver = void 0;
+class NullDriver {
+    constructor(_channel, _configs = {}) { }
+    transport(_message, _options) { }
+}
+exports.NullDriver = NullDriver;

package/src/Drivers/PinoDriver.d.ts

@@ -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 pino from 'pino';
+import pinoPretty from 'pino-pretty';
+import { DriverContract } from '../Contracts/DriverContract';
+export interface PinoDriverOpts extends pino.LoggerOptions {
+    formatter: 'pino-pretty';
+    formatterConfig: pinoPretty.PrettyOptions;
+}
+export declare class PinoDriver implements DriverContract {
+    configs: PinoDriverOpts;
+    constructor(channel: string, configs?: any);
+    transport(message: any, options?: Partial<PinoDriverOpts>): void;
+}

package/src/Drivers/PinoDriver.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * @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.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinoDriver = void 0;
+const pino_1 = __importDefault(require("pino"));
+const utils_1 = require("@secjs/utils");
+const groupConfigs_1 = require("../Utils/groupConfigs");
+const OnlyPinoPrettyException_1 = require("../Exceptions/OnlyPinoPrettyException");
+class PinoDriver {
+    constructor(channel, configs = {}) {
+        const channelConfig = utils_1.Config.get(`logging.channels.${channel}`);
+        this.configs = groupConfigs_1.groupConfigs(configs, channelConfig);
+    }
+    transport(message, options = {}) {
+        const configs = groupConfigs_1.groupConfigs(options, this.configs);
+        configs.customLevels = {
+            info: 1,
+            warn: 2,
+            error: 3,
+            debug: 4,
+            success: 5,
+        };
+        configs.useOnlyCustomLevels = true;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const pinoMethod = configs.formatterConfig.level.toLowerCase();
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        delete configs.formatterConfig.level;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        delete configs.formatterConfig.chalk;
+        if (configs.formatter !== 'pino-pretty') {
+            throw new OnlyPinoPrettyException_1.OnlyPinoPrettyException();
+        }
+        const pinoConfigs = {};
+        Object.keys(configs).forEach(key => {
+            if (key === 'formatter') {
+                pinoConfigs.transport = {
+                    target: 'pino-pretty',
+                    options: configs.formatterConfig,
+                };
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                configs.formatterConfig.customLevels =
+                    'info:1,warn:2,error:3,debug:4,success:5';
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                configs.formatterConfig.customColors =
+                    'info:cyan,warn:yellow,error:red,debug:magenta,success:green';
+                return;
+            }
+            if (['driver', 'formatterConfig'].includes(key)) {
+                return;
+            }
+            pinoConfigs[key] = configs[key];
+        });
+        const logger = pino_1.default(pinoConfigs);
+        return logger[pinoMethod](message);
+    }
+}
+exports.PinoDriver = PinoDriver;

package/src/Drivers/SlackDriver.d.ts

@@ -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 { DriverContract } from '../Contracts/DriverContract';
+export interface SlackDriverOpts {
+    url?: string;
+    formatter?: any;
+    formatterConfig?: any;
+}
+export declare class SlackDriver implements DriverContract {
+    configs: Required<SlackDriverOpts>;
+    constructor(channel: string, configs?: any);
+    transport(message: string, options?: SlackDriverOpts): Promise<void>;
+}

package/src/Drivers/SlackDriver.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * @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.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackDriver = void 0;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("@secjs/utils");
+const Color_1 = require("../Utils/Color");
+const groupConfigs_1 = require("../Utils/groupConfigs");
+const FormatterFactory_1 = require("../Factories/FormatterFactory");
+class SlackDriver {
+    constructor(channel, configs = {}) {
+        const channelConfig = utils_1.Config.get(`logging.channels.${channel}`);
+        this.configs = groupConfigs_1.groupConfigs(configs, channelConfig);
+    }
+    async transport(message, options = {}) {
+        const configs = groupConfigs_1.groupConfigs(options, this.configs);
+        message = FormatterFactory_1.FormatterFactory.fabricate(configs.formatter).format(message, configs.formatterConfig);
+        await axios_1.default.post(configs.url, { text: Color_1.Color.removeColors(message) });
+    }
+}
+exports.SlackDriver = SlackDriver;

package/src/Drivers/TelegramDriver.d.ts

@@ -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 { DriverContract } from '../Contracts/DriverContract';
+export interface TelegramDriverOpts {
+    token?: string;
+    chatId?: string | number;
+    parseMode?: 'HTML' | 'Markdown' | 'MarkdownV2';
+    formatter?: any;
+    formatterConfig?: any;
+}
+export declare class TelegramDriver implements DriverContract {
+    configs: Required<TelegramDriverOpts>;
+    constructor(channel: string, configs?: any);
+    transport(message: string, options?: TelegramDriverOpts): Promise<void>;
+}

package/src/Drivers/TelegramDriver.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * @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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramDriver = void 0;
+const telegraf_1 = require("telegraf");
+const utils_1 = require("@secjs/utils");
+const Color_1 = require("../Utils/Color");
+const groupConfigs_1 = require("../Utils/groupConfigs");
+const FormatterFactory_1 = require("../Factories/FormatterFactory");
+class TelegramDriver {
+    constructor(channel, configs = {}) {
+        const channelConfig = utils_1.Config.get(`logging.channels.${channel}`);
+        this.configs = groupConfigs_1.groupConfigs(configs, channelConfig);
+    }
+    async transport(message, options = {}) {
+        const configs = groupConfigs_1.groupConfigs(options, this.configs);
+        message = FormatterFactory_1.FormatterFactory.fabricate(configs.formatter).format(message, configs.formatterConfig);
+        await new telegraf_1.Telegraf(configs.token).telegram.sendMessage(configs.chatId, Color_1.Color.removeColors(message), {
+            parse_mode: configs.parseMode,
+        });
+    }
+}
+exports.TelegramDriver = TelegramDriver;

package/src/Exceptions/NotFoundFormatterException.js

@@ -12,7 +12,7 @@ exports.NotFoundFormatterException = void 0;
 const utils_1 = require("@secjs/utils");
 class NotFoundFormatterException extends utils_1.Exception {
     constructor(formatterName) {
-        const content = `The driver ${formatterName} has not been found`;
+        const content = `The formatter ${formatterName} has not been found`;
         super(content, 500, 'NOT_FOUND_ERROR', `Look into your config/logger file if this formatter is implemented by logger. Or create this formatter implementation using Logger.buildFormatter method`);
     }
 }

package/src/Exceptions/OnlyPinoPrettyException.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 '@secjs/utils';
+export declare class OnlyPinoPrettyException extends Exception {
+    constructor();
+}

package/src/Exceptions/OnlyPinoPrettyException.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnlyPinoPrettyException = void 0;
+const utils_1 = require("@secjs/utils");
+class OnlyPinoPrettyException extends utils_1.Exception {
+    constructor() {
+        const content = `The driver "pino" can only be used with "pino-pretty" formatter.`;
+        super(content, 500, 'ONLY_PINO-PRETTY_EXCEPTION', `Look into your config/logger file the formatter that you are trying to use with your channel configuration.`);
+    }
+}
+exports.OnlyPinoPrettyException = OnlyPinoPrettyException;

package/src/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 '../Logger';
+export declare const Log: Logger;

package/src/Facades/Log.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * @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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = void 0;
+const ioc_1 = require("@athenna/ioc");
+exports.Log = ioc_1.Facade.createFor('Athenna/Core/Logger');

package/src/Factories/DriverFactory.js

@@ -10,9 +10,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DriverFactory = void 0;
 const utils_1 = require("@secjs/utils");
+const PinoDriver_1 = require("../Drivers/PinoDriver");
 const FileDriver_1 = require("../Drivers/FileDriver");
+const NullDriver_1 = require("../Drivers/NullDriver");
 const DebugDriver_1 = require("../Drivers/DebugDriver");
+const SlackDriver_1 = require("../Drivers/SlackDriver");
 const ConsoleDriver_1 = require("../Drivers/ConsoleDriver");
+const DiscordDriver_1 = require("../Drivers/DiscordDriver");
+const TelegramDriver_1 = require("../Drivers/TelegramDriver");
 const NotFoundDriverException_1 = require("../Exceptions/NotFoundDriverException");
 const DriverAlreadyExistException_1 = require("../Exceptions/DriverAlreadyExistException");
 const ChannelNotConfiguredException_1 = require("../Exceptions/ChannelNotConfiguredException");
@@ -55,5 +60,10 @@ class DriverFactory {
 exports.DriverFactory = DriverFactory;
 DriverFactory.drivers = new Map()
     .set('file', { Driver: FileDriver_1.FileDriver })
+    .set('null', { Driver: NullDriver_1.NullDriver })
+    .set('pino', { Driver: PinoDriver_1.PinoDriver })
+    .set('slack', { Driver: SlackDriver_1.SlackDriver })
     .set('debug', { Driver: DebugDriver_1.DebugDriver })
-    .set('console', { Driver: ConsoleDriver_1.ConsoleDriver });
+    .set('console', { Driver: ConsoleDriver_1.ConsoleDriver })
+    .set('discord', { Driver: DiscordDriver_1.DiscordDriver })
+    .set('telegram', { Driver: TelegramDriver_1.TelegramDriver });

package/src/Factories/FormatterFactory.js

@@ -13,6 +13,7 @@ const CliFormatter_1 = require("../Formatters/CliFormatter");
 const JsonFormatter_1 = require("../Formatters/JsonFormatter");
 const NestFormatter_1 = require("../Formatters/NestFormatter");
 const SimpleFormatter_1 = require("../Formatters/SimpleFormatter");
+const MessageFormatter_1 = require("../Formatters/MessageFormatter");
 const RequestFormatter_1 = require("../Formatters/RequestFormatter");
 const NotFoundFormatterException_1 = require("../Exceptions/NotFoundFormatterException");
 const FormatterAlreadyExistException_1 = require("../Exceptions/FormatterAlreadyExistException");
@@ -44,4 +45,5 @@ FormatterFactory.formatters = new Map()
     .set('nest', { Formatter: NestFormatter_1.NestFormatter })
     .set('json', { Formatter: JsonFormatter_1.JsonFormatter })
     .set('simple', { Formatter: SimpleFormatter_1.SimpleFormatter })
+    .set('message', { Formatter: MessageFormatter_1.MessageFormatter })
     .set('request', { Formatter: RequestFormatter_1.RequestFormatter });

package/src/Formatters/CliFormatter.js

@@ -19,6 +19,8 @@ class CliFormatter {
             error: Color_1.Color.error,
             success: Color_1.Color.log,
         };
+        if (!levelColors[level.toLowerCase()])
+            return `[  ${level.toLowerCase()}  ]`;
         return levelColors[level.toLowerCase()](`[  ${level.toLowerCase()}  ]`);
     }
     format(message, options) {

package/src/Formatters/MessageFormatter.d.ts

@@ -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 { LevelTypes } from '../Contracts/LevelTypes';
+import { FormatterContract } from '../Contracts/FormatterContract';
+export interface MessageFormatterOpts {
+    level: LevelTypes;
+    customEmoji: string;
+}
+export declare class MessageFormatter implements FormatterContract {
+    private static lastTimestamp?;
+    private static getTimestampDiff;
+    private static getEmojiByLevel;
+    format(message: string, options: MessageFormatterOpts): string;
+}

package/src/Formatters/MessageFormatter.js

@@ -0,0 +1,43 @@
+"use strict";
+/* eslint-disable prettier/prettier */
+/**
+ * @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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageFormatter = void 0;
+const Color_1 = require("../Utils/Color");
+class MessageFormatter {
+    static getTimestampDiff() {
+        let result = '';
+        if (this.lastTimestamp) {
+            result = Color_1.Color.yellow(` +${Date.now() - this.lastTimestamp}ms`);
+        }
+        this.lastTimestamp = Date.now();
+        return result;
+    }
+    static getEmojiByLevel(level, customEmoji) {
+        if (customEmoji)
+            return customEmoji;
+        const levelEmojis = {
+            info: '\u{2139}',
+            debug: '\u{1F50E}',
+            warn: '\u{26A0}',
+            error: '\u{274C}',
+            success: '\u{2705}',
+        };
+        if (!levelEmojis[level.toLowerCase()])
+            return '';
+        return levelEmojis[level.toLowerCase()];
+    }
+    format(message, options) {
+        const timestampDiff = MessageFormatter.getTimestampDiff();
+        const level = MessageFormatter.getEmojiByLevel(options.level, options.customEmoji);
+        return `${level} ${message}${timestampDiff}`;
+    }
+}
+exports.MessageFormatter = MessageFormatter;

package/src/Formatters/SimpleFormatter.d.ts

@@ -9,7 +9,7 @@
 import { Chalk } from 'chalk';
 import { LevelTypes } from '../Contracts/LevelTypes';
 import { FormatterContract } from '../Contracts/FormatterContract';
-export interface LogFormatterOptions {
+export interface SimpleFormatterOpts {
     chalk: Chalk;
     level: LevelTypes;
 }
@@ -17,5 +17,5 @@ export declare class SimpleFormatter implements FormatterContract {
     private static lastTimestamp?;
     private static getTimestampDiff;
     private static paintByLevel;
-    format(message: string, options: LogFormatterOptions): string;
+    format(message: string, options: SimpleFormatterOpts): string;
 }

package/src/Formatters/SimpleFormatter.js

@@ -28,6 +28,8 @@ class SimpleFormatter {
             error: Color_1.Color.error,
             success: Color_1.Color.log,
         };
+        if (!levelColors[level.toLowerCase()])
+            return `[${level.toUpperCase()}]`;
         return levelColors[level.toLowerCase()](`[${level.toUpperCase()}]`);
     }
     format(message, options) {

package/src/Logger.d.ts

@@ -1,21 +1,110 @@
 import { DriverContract } from './Contracts/DriverContract';
 import { FormatterContract } from './Contracts/FormatterContract';
 export declare class Logger {
+    /**
+     * Runtime configurations to be used inside the Drivers and Formatters.
+     * @private
+     */
     private runtimeConfig;
-    private channelName;
+    /**
+     * The driver responsible for transporting the logs.
+     * @private
+     */
     private driver;
-    constructor(runtimeConfig?: any);
+    /**
+     * The log channel selected with driver and formatter configurations.
+     * @private
+     */
+    private channelName;
+    /**
+     * Creates a new instance of Logger.
+     *
+     * @return {Logger}
+     */
+    constructor();
+    /**
+     * Return all drivers available.
+     */
     static get drivers(): string[];
+    /**
+     * Return all formatters available.
+     */
     static get formatters(): string[];
+    /**
+     * Builds a new driver to use within Logger class.
+     *
+     * @param name
+     * @param driver
+     */
     static buildDriver(name: string, driver: new (channel: string, configs?: any) => DriverContract): void;
+    /**
+     * Builds a new formatter to use within Logger class.
+     *
+     * @param name
+     * @param formatter
+     */
     static buildFormatter(name: string, formatter: new () => FormatterContract): void;
+    /**
+     * Applies the log engine to execute chalk methods of string.
+     *
+     * @param content
+     * @private
+     */
     private static applyLogEngine;
+    /**
+     * Change the log channel.
+     *
+     * @param channel
+     * @param runtimeConfig
+     */
     channel(channel: string, runtimeConfig?: any): Logger;
+    /**
+     * Creates a log of type log in channel.
+     * @param message
+     * @param options
+     */
     log(message: any, options?: {}): void | Promise<void>;
+    /**
+     * Creates a log of type info in channel.
+     *
+     * @param message
+     * @param options
+     */
     info(message: any, options?: {}): void | Promise<void>;
+    /**
+     * Creates a log of type warn in channel.
+     *
+     * @param message
+     * @param options
+     */
     warn(message: any, options?: {}): void | Promise<void>;
+    /**
+     * Creates a log of type error in channel.
+     *
+     * @param message
+     * @param options
+     */
     error(message: any, options?: {}): void | Promise<void>;
+    /**
+     * Creates a log of type debug in channel.
+     *
+     * @param message
+     * @param options
+     */
     debug(message: any, options?: {}): void | Promise<void>;
+    /**
+     * Creates a log of type success in channel.
+     *
+     * @param message
+     * @param options
+     */
     success(message: any, options?: {}): void | Promise<void>;
+    /**
+     * Create options concatenating client options with default options.
+     *
+     * @param options
+     * @param defaultValues
+     * @private
+     */
     private createOptions;
 }

package/src/Logger.js

@@ -10,23 +10,60 @@ const Color_1 = require("./Utils/Color");
 const DriverFactory_1 = require("./Factories/DriverFactory");
 const FormatterFactory_1 = require("./Factories/FormatterFactory");
 class Logger {
-    constructor(runtimeConfig = {}) {
-        this.runtimeConfig = runtimeConfig;
+    /**
+     * Creates a new instance of Logger.
+     *
+     * @return {Logger}
+     */
+    constructor() {
+        /**
+         * Runtime configurations to be used inside the Drivers and Formatters.
+         * @private
+         */
+        this.runtimeConfig = {};
+        /**
+         * The log channel selected with driver and formatter configurations.
+         * @private
+         */
         this.channelName = 'default';
         this.driver = DriverFactory_1.DriverFactory.fabricate(this.channelName, this.runtimeConfig);
     }
+    /**
+     * Return all drivers available.
+     */
     static get drivers() {
         return DriverFactory_1.DriverFactory.availableDrivers();
     }
+    /**
+     * Return all formatters available.
+     */
     static get formatters() {
         return FormatterFactory_1.FormatterFactory.availableFormatters();
     }
+    /**
+     * Builds a new driver to use within Logger class.
+     *
+     * @param name
+     * @param driver
+     */
     static buildDriver(name, driver) {
         DriverFactory_1.DriverFactory.createDriver(name, driver);
     }
+    /**
+     * Builds a new formatter to use within Logger class.
+     *
+     * @param name
+     * @param formatter
+     */
     static buildFormatter(name, formatter) {
         FormatterFactory_1.FormatterFactory.createFormatter(name, formatter);
     }
+    /**
+     * Applies the log engine to execute chalk methods of string.
+     *
+     * @param content
+     * @private
+     */
     static applyLogEngine(content) {
         if (utils_1.Is.String(content)) {
             const matches = content.match(/\({(.*?)} (.*?)\)/);
@@ -49,22 +86,37 @@ class Logger {
         }
         return content;
     }
+    /**
+     * Change the log channel.
+     *
+     * @param channel
+     * @param runtimeConfig
+     */
     channel(channel, runtimeConfig) {
         if (runtimeConfig)
             this.runtimeConfig = runtimeConfig;
         this.driver = DriverFactory_1.DriverFactory.fabricate(channel, this.runtimeConfig);
+        this.channelName = channel;
         return this;
     }
+    /**
+     * Creates a log of type log in channel.
+     * @param message
+     * @param options
+     */
     log(message, options = {}) {
-        options = this.createOptions(options, {
-            streamType: 'stdout',
-        });
+        options = this.createOptions(options, {});
         message = Logger.applyLogEngine(message);
         return this.driver.transport(message, options);
     }
+    /**
+     * Creates a log of type info in channel.
+     *
+     * @param message
+     * @param options
+     */
     info(message, options = {}) {
         options = this.createOptions(options, {
-            streamType: 'stdout',
             formatterConfig: {
                 level: 'INFO',
                 chalk: Color_1.Color.cyan,
@@ -73,9 +125,14 @@ class Logger {
         message = Logger.applyLogEngine(message);
         return this.driver.transport(message, options);
     }
+    /**
+     * Creates a log of type warn in channel.
+     *
+     * @param message
+     * @param options
+     */
     warn(message, options = {}) {
         options = this.createOptions(options, {
-            streamType: 'stdout',
             formatterConfig: {
                 level: 'WARN',
                 chalk: Color_1.Color.orange,
@@ -84,9 +141,14 @@ class Logger {
         message = Logger.applyLogEngine(message);
         return this.driver.transport(message, options);
     }
+    /**
+     * Creates a log of type error in channel.
+     *
+     * @param message
+     * @param options
+     */
     error(message, options = {}) {
         options = this.createOptions(options, {
-            streamType: 'stdout',
             formatterConfig: {
                 level: 'ERROR',
                 chalk: Color_1.Color.red,
@@ -95,9 +157,14 @@ class Logger {
         message = Logger.applyLogEngine(message);
         return this.driver.transport(message, options);
     }
+    /**
+     * Creates a log of type debug in channel.
+     *
+     * @param message
+     * @param options
+     */
     debug(message, options = {}) {
         options = this.createOptions(options, {
-            streamType: 'stdout',
             formatterConfig: {
                 level: 'DEBUG',
                 chalk: Color_1.Color.purple,
@@ -106,9 +173,14 @@ class Logger {
         message = Logger.applyLogEngine(message);
         return this.driver.transport(message, options);
     }
+    /**
+     * Creates a log of type success in channel.
+     *
+     * @param message
+     * @param options
+     */
     success(message, options = {}) {
         options = this.createOptions(options, {
-            streamType: 'stdout',
             formatterConfig: {
                 level: 'SUCCESS',
                 chalk: Color_1.Color.green,
@@ -117,6 +189,13 @@ class Logger {
         message = Logger.applyLogEngine(message);
         return this.driver.transport(message, options);
     }
+    /**
+     * Create options concatenating client options with default options.
+     *
+     * @param options
+     * @param defaultValues
+     * @private
+     */
     createOptions(options, defaultValues) {
         let formatterConfig = Object.assign({}, {
             ...defaultValues.formatterConfig,
@@ -127,9 +206,6 @@ class Logger {
                 ...formatterConfig,
             };
         }
-        options = Object.assign({}, {
-            streamType: 'stdout',
-        }, options);
         options = {
             ...options,
             formatterConfig,

package/src/Providers/LoggerProvider.js

@@ -18,7 +18,7 @@ class LoggerProvider extends ioc_1.ServiceProvider {
      * @return void
      */
     register() {
-        this.container.instance('Athenna/Core/Logger', new Logger_1.Logger());
+        this.container.bind('Athenna/Core/Logger', Logger_1.Logger);
     }
 }
 exports.LoggerProvider = LoggerProvider;

package/src/Utils/groupConfigs.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @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 function groupConfigs<T = any>(main: any, fallback: any): Required<T>;

package/src/Utils/groupConfigs.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupConfigs = void 0;
+function groupConfigs(main, fallback) {
+    const formatter = main.formatter || fallback.formatter;
+    const formatterConfig = Object.assign({}, fallback.formatterConfig, main.formatterConfig);
+    const driverConfig = Object.assign({}, fallback, main);
+    return { ...driverConfig, formatter, formatterConfig };
+}
+exports.groupConfigs = groupConfigs;