@athenna/logger 1.1.6 → 1.1.9

package/src/Drivers/PinoDriver.js

@@ -0,0 +1,94 @@
+/**
+ * @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 { Config } from '@secjs/utils'
+
+import { FactoryHelper } from '#src/index'
+import { OnlyPinoPrettyException } from '#src/Exceptions/OnlyPinoPrettyException'
+
+export class PinoDriver {
+  /**
+   * Holds the configuration set of PinoDriver.
+   *
+   * @type {import('pino').LoggerOptions & { formatter?: 'pino-pretty', formatterConfig?: import('pino-pretty').PrettyOptions }}
+   */
+  configs
+
+  /**
+   * Creates a new instance of PinoDriver.
+   *
+   * @param {string} channel
+   * @param {any} [configs]
+   * @return {PinoDriver}
+   */
+  constructor(channel, configs = {}) {
+    const channelConfig = Config.get(`logging.channels.${channel}`)
+
+    this.configs = FactoryHelper.groupConfigs(configs, channelConfig)
+  }
+
+  /**
+   * Transport the log.
+   *
+   * @param {string} message
+   * @param {import('pino').LoggerOptions & { formatter?: 'pino-pretty', formatterConfig?: import('pino-pretty').PrettyOptions }} [options]
+   * @return {void}
+   */
+  transport(message, options = {}) {
+    const configs = FactoryHelper.groupConfigs(options, this.configs)
+
+    configs.customLevels = {
+      info: 1,
+      warn: 2,
+      error: 3,
+      debug: 4,
+      success: 5,
+      critical: 6,
+    }
+    configs.useOnlyCustomLevels = true
+
+    const pinoMethod = configs.formatterConfig.level.toLowerCase()
+
+    delete configs.formatterConfig.level
+    delete configs.formatterConfig.chalk
+
+    if (configs.formatter !== 'pino-pretty') {
+      throw new OnlyPinoPrettyException()
+    }
+
+    const pinoConfigs = {}
+
+    Object.keys(configs).forEach(key => {
+      if (key === 'formatter') {
+        pinoConfigs.transport = {
+          target: 'pino-pretty',
+          options: configs.formatterConfig,
+        }
+        configs.formatterConfig.customLevels =
+          'info:1,warn:2,error:3,debug:4,success:5,critical:6'
+        configs.formatterConfig.customColors =
+          'info:cyan,warn:yellow,error:red,debug:magenta,success:green,critical:red'
+
+        return
+      }
+
+      if (['driver', 'formatterConfig'].includes(key)) {
+        return
+      }
+
+      pinoConfigs[key] = configs[key]
+    })
+
+    const logger = pino(pinoConfigs)
+
+    logger[pinoMethod](message)
+  }
+}

package/src/Drivers/SlackDriver.js

@@ -0,0 +1,54 @@
+/**
+ * @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 axios from 'axios'
+
+import { Config } from '@secjs/utils'
+
+import { ColorHelper, FactoryHelper, FormatterFactory } from '#src/index'
+
+export class SlackDriver {
+  /**
+   * Holds the configuration set of SlackDriver.
+   *
+   * @type {{ url?: string, formatter?: 'pino-pretty', formatterConfig?: import('pino-pretty').PrettyOptions }}
+   */
+  configs
+
+  /**
+   * Creates a new instance of SlackDriver.
+   *
+   * @param {string} channel
+   * @param {any} [configs]
+   * @return {SlackDriver}
+   */
+  constructor(channel, configs = {}) {
+    const channelConfig = Config.get(`logging.channels.${channel}`)
+
+    this.configs = FactoryHelper.groupConfigs(configs, channelConfig)
+  }
+
+  /**
+   * Transport the log.
+   *
+   * @param {string} message
+   * @param {{ url?: string, formatter?: 'pino-pretty', formatterConfig?: import('pino-pretty').PrettyOptions }} [options]
+   * @return {Promise<void>}
+   */
+  async transport(message, options = {}) {
+    const configs = FactoryHelper.groupConfigs(options, this.configs)
+
+    message = FormatterFactory.fabricate(configs.formatter).format(
+      message,
+      configs.formatterConfig,
+    )
+
+    await axios.post(configs.url, { text: ColorHelper.removeColors(message) })
+  }
+}

package/src/Drivers/TelegramDriver.js

@@ -0,0 +1,53 @@
+/**
+ * @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 { Config } from '@secjs/utils'
+
+import { ColorHelper, FactoryHelper, FormatterFactory } from '#src/index'
+
+export class TelegramDriver {
+  /**
+   * Holds the configuration set of SlackDriver.
+   *
+   * @type {{ token?: string, chatId?: string|number, parseMode?: 'HTML'|'Markdown'|'MarkdownV2', formatter?: 'pino-pretty', formatterConfig?: import('pino-pretty').PrettyOptions }}
+   */
+  configs
+
+  constructor(channel, configs = {}) {
+    const channelConfig = Config.get(`logging.channels.${channel}`)
+
+    this.configs = FactoryHelper.groupConfigs(configs, channelConfig)
+  }
+
+  /**
+   * Transport the log.
+   *
+   * @param {string} message
+   * @param {{ token?: string, chatId?: string|number, parseMode?: 'HTML'|'Markdown'|'MarkdownV2', formatter?: 'pino-pretty', formatterConfig?: import('pino-pretty').PrettyOptions }} [options]
+   * @return {Promise<void>}
+   */
+  async transport(message, options = {}) {
+    const configs = FactoryHelper.groupConfigs(options, this.configs)
+
+    message = FormatterFactory.fabricate(configs.formatter).format(
+      message,
+      configs.formatterConfig,
+    )
+
+    await new Telegraf(configs.token).telegram.sendMessage(
+      configs.chatId,
+      ColorHelper.removeColors(message),
+      {
+        parse_mode: configs.parseMode,
+      },
+    )
+  }
+}

package/src/Exceptions/DriverExistException.js

@@ -0,0 +1,31 @@
+/**
+ * @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'
+import { DriverFactory } from '#src/Factories/DriverFactory'
+
+export class DriverExistException extends Exception {
+  /**
+   * Creates a new instance of DriverExistException.
+   *
+   * @param {string} driverName
+   * @return {DriverExistException}
+   */
+  constructor(driverName) {
+    const content = `The driver ${driverName} already exists in DriverFactory.`
+    const availableDrivers = DriverFactory.availableDrivers().join(', ')
+
+    super(
+      content,
+      500,
+      'E_EXIST_DRIVER',
+      `Available drivers are: ${availableDrivers}. The name ${driverName} is already in use inside DriverFactory. Try using a different name for your driver implementation.`,
+    )
+  }
+}

package/src/Exceptions/FormatterExistException.js

@@ -0,0 +1,32 @@
+/**
+ * @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'
+import { FormatterFactory } from '#src/Factories/FormatterFactory'
+
+export class FormatterExistException extends Exception {
+  /**
+   * Creates a new instance of FormatterExistException.
+   *
+   * @param {string} formatterName
+   * @return {FormatterExistException}
+   */
+  constructor(formatterName) {
+    const content = `The formatter ${formatterName} already exists in FormatterFactory.`
+    const availableFormatters =
+      FormatterFactory.availableFormatters().join(', ')
+
+    super(
+      content,
+      500,
+      'E_EXIST_FORMATTER',
+      `Available formatters are: ${availableFormatters}. The name ${formatterName} is already in use inside FormatterFactory. Try using a different name for your formatter implementation.`,
+    )
+  }
+}

package/src/Exceptions/NotFoundChannelException.js

@@ -0,0 +1,32 @@
+/**
+ * @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, Exception } from '@secjs/utils'
+
+export class NotFoundChannelException extends Exception {
+  /**
+   * Creates a new instance of NotFoundChannelException.
+   *
+   * @param {string} channelName
+   * @return {NotFoundChannelException}
+   */
+  constructor(channelName) {
+    const content = `Channel ${channelName} not found.`
+    const availableChannels = Object.keys(Config.get('logging.channels')).join(
+      ', ',
+    )
+
+    super(
+      content,
+      500,
+      'E_NOT_FOUND',
+      `Available channels are: ${availableChannels}. Look into your config/logger file if ${channelName} channel is inside "channels" property, if it does not exist create ${channelName} channel object inside "channels".`,
+    )
+  }
+}

package/src/Exceptions/NotFoundDriverException.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @athenna/logger
  *
@@ -7,13 +6,26 @@
  * 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.NotFoundDriverException = void 0;
-const utils_1 = require("@secjs/utils");
-class NotFoundDriverException extends utils_1.Exception {
-    constructor(driverName) {
-        const content = `The driver ${driverName} has not been found`;
-        super(content, 500, 'NOT_FOUND_ERROR', `Look into your config/logger file if this driver is implemented by logger. Or create this driver implementation using Logger.buildDriver method`);
-    }
+
+import { Exception } from '@secjs/utils'
+import { DriverFactory } from '#src/Factories/DriverFactory'
+
+export class NotFoundDriverException extends Exception {
+  /**
+   * Creates a new instance of NotFoundDriverException.
+   *
+   * @param {string} driverName
+   * @return {NotFoundDriverException}
+   */
+  constructor(driverName) {
+    const content = `The driver ${driverName} has not been found.`
+    const availableDrivers = DriverFactory.availableDrivers().join(', ')
+
+    super(
+      content,
+      500,
+      'E_NOT_FOUND',
+      `Available drivers are: ${availableDrivers}. Look into your config/logger file if ${driverName} driver is implemented by logger. Or create ${driverName} driver implementation using DriverFactory.createDriver("${driverName}", ...) method.`,
+    )
+  }
 }
-exports.NotFoundDriverException = NotFoundDriverException;

package/src/Exceptions/NotFoundFormatterException.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @athenna/logger
  *
@@ -7,13 +6,26 @@
  * 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.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`;
-        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`);
-    }
+
+import { Exception } from '@secjs/utils'
+import { FormatterFactory } from '#src/Factories/FormatterFactory'
+
+export class NotFoundFormatterException extends Exception {
+  /**
+   * Creates a new instance of NotFoundFormatterException.
+   *
+   * @param {string} formatterName
+   * @return {NotFoundFormatterException}
+   */
+  constructor(formatterName) {
+    const content = `The formatter ${formatterName} has not been found.`
+    const availableDrivers = FormatterFactory.availableFormatters().join(', ')
+
+    super(
+      content,
+      500,
+      'E_NOT_FOUND',
+      `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.`,
+    )
+  }
 }
-exports.NotFoundFormatterException = NotFoundFormatterException;

package/src/Exceptions/OnlyPinoPrettyException.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 { Exception } from '@secjs/utils'
+
+export class OnlyPinoPrettyException extends Exception {
+  /**
+   * Creates a new instance of OnlyPinoPrettyException.
+   *
+   * @return {OnlyPinoPrettyException}
+   */
+  constructor() {
+    const content = `The driver "pino" can only be used with "pino-pretty" formatter.`
+
+    super(
+      content,
+      500,
+      'E_PINO_PRETTY',
+      `Available formatters are: pino-pretty. Look into your config/logger file where your are using "pino" driver and change the formatter to pino-pretty.`,
+    )
+  }
+}

package/src/Facades/Log.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @athenna/logger
  *
@@ -7,7 +6,12 @@
  * 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 Handler_1 = require("../Utils/Handler");
-exports.Log = new Proxy({}, new Handler_1.Handler('Athenna/Core/Logger'));
+
+import { Facade } from '@athenna/ioc'
+
+/**
+ * Log facade.
+ *
+ * @type {Facade & import('../index').Logger}
+ */
+export const Log = Facade.createFor('Athenna/Core/Logger')

package/src/Factories/DriverFactory.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @athenna/logger
  *
@@ -7,53 +6,106 @@
  * 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.DriverFactory = void 0;
-const utils_1 = require("@secjs/utils");
-const FileDriver_1 = require("../Drivers/FileDriver");
-const DebugDriver_1 = require("../Drivers/DebugDriver");
-const ConsoleDriver_1 = require("../Drivers/ConsoleDriver");
-const NotFoundDriverException_1 = require("../Exceptions/NotFoundDriverException");
-const DriverAlreadyExistException_1 = require("../Exceptions/DriverAlreadyExistException");
-const ChannelNotConfiguredException_1 = require("../Exceptions/ChannelNotConfiguredException");
-class DriverFactory {
-    static availableDrivers() {
-        const availableDrivers = [];
-        for (const [key] of this.drivers.entries()) {
-            availableDrivers.push(key);
-        }
-        return availableDrivers;
+
+import { Config } from '@secjs/utils'
+
+import { FileDriver } from '#src/Drivers/FileDriver'
+import { NullDriver } from '#src/Drivers/NullDriver'
+import { PinoDriver } from '#src/Drivers/PinoDriver'
+import { DebugDriver } from '#src/Drivers/DebugDriver'
+import { SlackDriver } from '#src/Drivers/SlackDriver'
+import { ConsoleDriver } from '#src/Drivers/ConsoleDriver'
+import { DiscordDriver } from '#src/Drivers/DiscordDriver'
+import { TelegramDriver } from '#src/Drivers/TelegramDriver'
+import { DriverExistException } from '#src/Exceptions/DriverExistException'
+import { NotFoundDriverException } from '#src/Exceptions/NotFoundDriverException'
+import { NotFoundChannelException } from '#src/Exceptions/NotFoundChannelException'
+
+export class DriverFactory {
+  /**
+   * Drivers of DriverFactory.
+   *
+   * @type {Map<string, { Driver: any }>}
+   */
+  static drivers = new Map()
+    .set('file', { Driver: FileDriver })
+    .set('null', { Driver: NullDriver })
+    .set('pino', { Driver: PinoDriver })
+    .set('slack', { Driver: SlackDriver })
+    .set('debug', { Driver: DebugDriver })
+    .set('console', { Driver: ConsoleDriver })
+    .set('discord', { Driver: DiscordDriver })
+    .set('telegram', { Driver: TelegramDriver })
+
+  /**
+   * Return an array with all available drivers.
+   *
+   * @return {any[]}
+   */
+  static availableDrivers() {
+    const availableDrivers = []
+
+    for (const [key] of this.drivers.entries()) {
+      availableDrivers.push(key)
     }
-    static fabricate(channelName, runtimeConfig = {}) {
-        if (channelName === 'default') {
-            channelName = utils_1.Config.get('logging.default');
-        }
-        const channelConfig = this.getChannelConfig(channelName);
-        const driverObject = this.drivers.get(channelConfig.driver);
-        if (!driverObject) {
-            throw new NotFoundDriverException_1.NotFoundDriverException(channelConfig.driver);
-        }
-        return new driverObject.Driver(channelName, runtimeConfig);
+
+    return availableDrivers
+  }
+
+  /**
+   * Fabricate a new instance of a driver based on
+   * channel configurations.
+   *
+   * @param {string} channelName
+   * @param {any} runtimeConfig
+   * @return {any}
+   */
+  static fabricate(channelName, runtimeConfig = {}) {
+    if (channelName === 'default') {
+      channelName = Config.get('logging.default')
     }
-    static createDriver(name, driver) {
-        if (this.drivers.has(name)) {
-            throw new DriverAlreadyExistException_1.DriverAlreadyExistException(name);
-        }
-        this.drivers.set(name, { Driver: driver });
+
+    const channelConfig = this.#getChannelConfig(channelName)
+    const driverObject = this.drivers.get(channelConfig.driver)
+
+    if (!driverObject) {
+      throw new NotFoundDriverException(channelConfig.driver)
     }
-    static getChannelConfig(channelName) {
-        const channelConfig = utils_1.Config.get(`logging.channels.${channelName}`);
-        if (!channelConfig) {
-            throw new ChannelNotConfiguredException_1.ChannelNotConfiguredException(channelName);
-        }
-        if (!this.drivers.has(channelConfig.driver)) {
-            throw new NotFoundDriverException_1.NotFoundDriverException(channelConfig.driver);
-        }
-        return channelConfig;
+
+    return new driverObject.Driver(channelName, runtimeConfig)
+  }
+
+  /**
+   * Creates a new driver implementation.
+   *
+   * @param {string} name
+   * @param {(channel: string, configs?: any) => any} driver
+   */
+  static createDriver(name, driver) {
+    if (this.drivers.has(name)) {
+      throw new DriverExistException(name)
     }
+
+    this.drivers.set(name, { Driver: driver })
+  }
+
+  /**
+   * Get all the configuration of a channel.
+   *
+   * @param {string} channelName
+   * @return {any}
+   */
+  static #getChannelConfig(channelName) {
+    const channelConfig = Config.get(`logging.channels.${channelName}`)
+
+    if (!channelConfig) {
+      throw new NotFoundChannelException(channelName)
+    }
+
+    if (!this.drivers.has(channelConfig.driver)) {
+      throw new NotFoundDriverException(channelConfig.driver)
+    }
+
+    return channelConfig
+  }
 }
-exports.DriverFactory = DriverFactory;
-DriverFactory.drivers = new Map()
-    .set('file', { Driver: FileDriver_1.FileDriver })
-    .set('debug', { Driver: DebugDriver_1.DebugDriver })
-    .set('console', { Driver: ConsoleDriver_1.ConsoleDriver });