@athenna/logger 1.2.8 → 1.2.9

package/src/index.js

@@ -1,31 +1,34 @@
-import Chalk from 'chalk'
+import { Chalk } from 'chalk'
+import { Is } from '@secjs/utils'
+import { format } from 'node:util'
 
-import { Is, Options } from '@secjs/utils'
-
-import { ColorHelper } from '#src/Helpers/ColorHelper'
 import { DriverFactory } from '#src/Factories/DriverFactory'
-import { FormatterFactory } from '#src/Factories/FormatterFactory'
 
 export * from './Facades/Log.js'
+
 export * from './Helpers/ColorHelper.js'
 export * from './Helpers/FactoryHelper.js'
+
+export * from './Drivers/Driver.js'
+export * from './Formatters/Formatter.js'
+
 export * from './Factories/DriverFactory.js'
 export * from './Factories/FormatterFactory.js'
 
 export class Logger {
   /**
-   * Runtime configurations to be used inside the Drivers and Formatters.
+   * The driver responsible for transporting the logs.
    *
-   * @type {any}
+   * @type {any[]}
    */
-  #runtimeConfig = {}
+  #drivers = []
 
   /**
-   * The driver responsible for transporting the logs.
+   * Runtime configurations to be used inside the Drivers and Formatters.
    *
-   * @type {any[]}
+   * @type {any}
    */
-  #drivers = []
+  #runtimeConfigs = {}
 
   /**
    * Creates a new instance of Logger.
@@ -33,229 +36,163 @@ export class Logger {
    * @return {Logger}
    */
   constructor() {
-    this.#drivers.push(DriverFactory.fabricate('default', this.#runtimeConfig))
+    this.#drivers.push(DriverFactory.fabricate('default', this.#runtimeConfigs))
   }
 
   /**
-   * Return all drivers available.
+   * Set runtime configurations for drivers and
+   * formatters.
    *
-   * @return {string[]}
+   * @param {any} runtimeConfigs
+   * @return {Logger}
    */
-  static get drivers() {
-    return DriverFactory.availableDrivers()
-  }
+  config(runtimeConfigs) {
+    this.#runtimeConfigs = runtimeConfigs
 
-  /**
-   * Return all formatters available.
-   *
-   * @return {string[]}
-   */
-  static get formatters() {
-    return FormatterFactory.availableFormatters()
+    return this
   }
 
   /**
-   * Applies the log engine to execute chalk methods of string.
+   * Change the log channel.
    *
-   * @param {string} content
+   * @param {string} channels
+   * @return {Logger}
    */
-  static #applyLogEngine(content) {
-    if (Is.String(content)) {
-      const matches = content.match(/\({(.*?)} (.*?)\)/)
-
-      if (matches) {
-        const chalkMethodsString = matches[1].replace(/\s/g, '')
-        const chalkMethodsArray = chalkMethodsString.split(',')
-        const message = matches[2]
-
-        let chalk = Chalk
-
-        chalkMethodsArray.forEach(chalkMethod => {
-          if (!chalk[chalkMethod]) return
-
-          chalk = chalk[chalkMethod]
-        })
-
-        content = content
-          .replace(`({${matches[1]}} `, '')
-          .replace(`({${matches[1]}}`, '')
-          .replace(`${matches[2]})`, chalk(message))
-      }
+  channel(...channels) {
+    this.#drivers = []
 
-      return content
-    }
+    channels.forEach(c => {
+      this.#drivers.push(DriverFactory.fabricate(c, this.#runtimeConfigs))
+    })
 
-    return content
+    return this
   }
 
   /**
-   * Transport the log.
+   * Call drivers to transport the log.
    *
-   * @param {string|any} message
-   * @param {any} [options]
-   * @param {any} [defaultValues]
-   * @return {void | Promise<void>}
+   * @param {string} level
+   * @param {string} args
+   * @return {any | Promise<any>}
    */
-  #log(message, options = {}, defaultValues = {}) {
-    options = this.#createOptions(options, defaultValues)
+  #log(level, ...args) {
+    const message = this.#applyEngine(...args)
 
-    message = Logger.#applyLogEngine(message)
-
-    const promises = this.#drivers.map(d => d.transport(message, options))
+    const promises = this.#drivers.map(d => d.transport(level, message))
 
     return Promise.all(promises)
   }
 
   /**
-   * Create options concatenating client options with default options.
+   * Creates a log of type trace in channel.
    *
-   * @param {any} options
-   * @param {any} defaultValues
-   * @return {any}
+   * @param {string|any} args
+   * @return {any | Promise<any>}
    */
-  #createOptions(options, defaultValues) {
-    let formatterConfig = Options.create(
-      options.formatterConfig,
-      defaultValues.formatterConfig,
-    )
-
-    if (this.#runtimeConfig.formatterConfig) {
-      formatterConfig = {
-        ...this.#runtimeConfig.formatterConfig,
-        ...formatterConfig,
-      }
-    }
-
-    options = {
-      ...options,
-      formatterConfig,
-    }
-
-    return options
+  trace(...args) {
+    return this.#log('trace', ...args)
   }
 
   /**
-   * Set runtime configurations for drivers and
-   * formatters.
+   * Creates a log of type debug in channel.
    *
-   * @param {any} runtimeConfig
-   * @return {Logger}
+   * @param {string|any} args
+   * @return {any | Promise<any>}
    */
-  config(runtimeConfig) {
-    this.#runtimeConfig = runtimeConfig
-
-    return this
+  debug(...args) {
+    return this.#log('debug', ...args)
   }
 
   /**
-   * Change the log channel.
+   * Creates a log of type info in channel.
    *
-   * @param {string[]} channels
-   * @return {Logger}
+   * @param {string|any} args
+   * @return {any | Promise<any>}
    */
-  channel(...channels) {
-    this.#drivers = []
-
-    channels.forEach(channel => {
-      this.#drivers.push(DriverFactory.fabricate(channel, this.#runtimeConfig))
-    })
-
-    return this
+  info(...args) {
+    return this.#log('info', ...args)
   }
 
   /**
-   * Creates a log of type info in channel.
+   * Creates a log of type success in channel.
    *
-   * @param {string|any} message
-   * @param {any} [options]
-   * @return {void | Promise<void>}
+   * @param {string|any} args
+   * @return {any | Promise<any>}
    */
-  info(message, options = {}) {
-    return this.#log(message, options, {
-      formatterConfig: {
-        level: 'INFO',
-        chalk: ColorHelper.cyan,
-      },
-    })
+  success(...args) {
+    return this.#log('success', ...args)
   }
 
   /**
    * Creates a log of type warn in channel.
    *
-   * @param {string|any} message
-   * @param {any} [options]
-   * @return {void | Promise<void>}
+   * @param {string|any} args
+   * @return {any | Promise<any>}
    */
-  warn(message, options = {}) {
-    return this.#log(message, options, {
-      formatterConfig: {
-        level: 'WARN',
-        chalk: ColorHelper.orange,
-      },
-    })
+  warn(...args) {
+    return this.#log('warn', ...args)
   }
 
   /**
    * Creates a log of type error in channel.
    *
-   * @param {string|any} message
-   * @param {any} [options]
-   * @return {void | Promise<void>}
+   * @param {string|any} args
+   * @return {any | Promise<any>}
    */
-  error(message, options = {}) {
-    return this.#log(message, options, {
-      formatterConfig: {
-        level: 'ERROR',
-        chalk: ColorHelper.red,
-      },
-    })
+  error(...args) {
+    return this.#log('error', ...args)
   }
 
   /**
-   * Creates a log of type critical in channel.
+   * Creates a log of type fatal in channel.
    *
-   * @param {string|any} message
-   * @param {any} [options]
-   * @return {void | Promise<void>}
+   * @param {string|any} args
+   * @return {any | Promise<any>}
    */
-  critical(message, options = {}) {
-    return this.#log(message, options, {
-      formatterConfig: {
-        level: 'CRITICAL',
-        chalk: ColorHelper.darkRed,
-      },
-    })
+  fatal(...args) {
+    return this.#log('fatal', ...args)
   }
 
   /**
-   * Creates a log of type debug in channel.
+   * Applies the log engine to execute chalk methods.
    *
-   * @param {string|any} message
-   * @param {any} [options]
-   * @return {void | Promise<void>}
+   * @param {string} args
+   * @return {any}
    */
-  debug(message, options = {}) {
-    return this.#log(message, options, {
-      formatterConfig: {
-        level: 'DEBUG',
-        chalk: ColorHelper.purple,
-      },
-    })
-  }
+  #applyEngine(...args) {
+    if (!Is.String(args[0])) {
+      return args[0]
+    }
 
-  /**
-   * Creates a log of type success in channel.
-   *
-   * @param {string|any} message
-   * @param {any} [options]
-   * @return {void | Promise<void>}
-   */
-  success(message, options = {}) {
-    return this.#log(message, options, {
-      formatterConfig: {
-        level: 'SUCCESS',
-        chalk: ColorHelper.green,
-      },
+    let content = format(...args)
+
+    const matches = content.match(/\({(.*?)} (.*?)\)/g)
+
+    if (!matches) {
+      return content
+    }
+
+    matches.forEach(match => {
+      const [chalkMethodsInBrackets, chalkMethodsString] =
+        match.match(/\{(.*?)\}/)
+
+      const message = match
+        .replace(chalkMethodsInBrackets, '')
+        .replace(/\s*\(\s*|\s*\)\s*/g, '')
+
+      const chalkMethodsArray = chalkMethodsString.replace(/\s/g, '').split(',')
+
+      let chalk = new Chalk()
+
+      chalkMethodsArray.forEach(chalkMethod => {
+        if (!chalk[chalkMethod]) return
+
+        chalk = chalk[chalkMethod]
+      })
+
+      content = content.replace(match, chalk(message))
     })
+
+    return content
   }
 }

package/src/Drivers/DebugDriver.js

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

package/src/Drivers/PinoDriver.js

@@ -1,94 +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 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/Exceptions/NotFoundChannelException.js

@@ -1,32 +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 { 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/OnlyPinoPrettyException.js

@@ -1,28 +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 { 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/Formatters/NestFormatter.js

@@ -1,40 +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 { ColorHelper, FactoryHelper } from '#src/index'
-
-export class NestFormatter {
-  /**
-   * The last timestamp.
-   *
-   * @type {number}
-   */
-  #lastTimestamp
-
-  /**
-   * Format the message.
-   *
-   * @param {string} message
-   * @param {{ context: string, chalk: import('chalk').ChalkInstance }} options
-   * @return {string}
-   */
-  format(message, options) {
-    const timestampDiff = FactoryHelper.getTimestampDiff(this.#lastTimestamp)
-
-    this.#lastTimestamp = Date.now()
-
-    const pid = ColorHelper.yellow(`[Athenna] - PID: ${process.pid}`)
-    const timestamp = FactoryHelper.getTimestamp()
-    const messageCtx = ColorHelper.yellow(`[${options.context}] `)
-
-    return `${pid} - ${timestamp} ${messageCtx}${options.chalk(
-      message,
-    )}${timestampDiff}`
-  }
-}