@athenna/logger 1.1.8 → 1.2.1

package/src/index.d.ts

@@ -0,0 +1,383 @@
+import { Facade } from '@athenna/ioc'
+
+/**
+ * Log facade.
+ *
+ * @type {Facade & import('../index').Logger}
+ */
+export const Log: Facade & Logger
+
+export class ColorHelper {
+  /**
+   * Chalk instance.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static chalk: import('chalk').ChalkInstance
+
+  /**
+   * Paint as bold.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get bold(): import('chalk').ChalkInstance
+
+  /**
+   * Paint as purple.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get purple(): import('chalk').ChalkInstance
+
+  /**
+   * Paint as darkPurple.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get darkPurple(): import('chalk').ChalkInstance
+
+  /**
+   * Paint as yellow.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get yellow(): import('chalk').ChalkInstance
+
+  /**
+   * Paint as cyan.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get cyan(): import('chalk').ChalkInstance
+
+  /**
+   * Paint as white.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get white(): import('chalk').ChalkInstance
+
+  /**
+   * Paint as orange.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get orange(): import('chalk').ChalkInstance
+
+  /**
+   * Paint as green.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get green(): import('chalk').ChalkInstance
+
+  /**
+   * Paint as darkGreen.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get darkGreen(): import('chalk').ChalkInstance
+
+  /**
+   * Paint as red.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get red(): import('chalk').ChalkInstance
+
+  /**
+   * Paint infos.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get info(): import('chalk').ChalkInstance
+
+  /**
+   * Paint logs.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get log(): import('chalk').ChalkInstance
+
+  /**
+   * Paint debugs.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get debug(): import('chalk').ChalkInstance
+
+  /**
+   * Paint errors.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get error(): import('chalk').ChalkInstance
+
+  /**
+   * Paint warnings.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get warning(): import('chalk').ChalkInstance
+
+  /**
+   * Paint http method.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get GET(): import('chalk').ChalkInstance
+
+  /**
+   * Paint http method.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get HEAD(): import('chalk').ChalkInstance
+
+  /**
+   * Paint http method.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get PUT(): import('chalk').ChalkInstance
+
+  /**
+   * Paint http method.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get PATCH(): import('chalk').ChalkInstance
+
+  /**
+   * Paint http method.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get POST(): import('chalk').ChalkInstance
+
+  /**
+   * Paint http method.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get DELETE(): import('chalk').ChalkInstance
+
+  /**
+   * Paint http method.
+   *
+   * @return {import('chalk').ChalkInstance}
+   */
+  static get OPTIONS(): import('chalk').ChalkInstance
+
+  /**
+   * Remove all colors and special chars of string.
+   *
+   * @param {string} string
+   * @return {import('chalk').ChalkInstance}
+   */
+  static removeColors(string: string): import('chalk').ChalkInstance
+
+  /**
+   * Paint by the http method.
+   *
+   * @param {'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH', 'OPTIONS', 'HEAD' } method
+   * @return {import('chalk').ChalkInstance}
+   */
+  static httpMethod(method: any): import('chalk').ChalkInstance
+}
+
+export class FactoryHelper {
+  /**
+   * Get the timestamp value formatted.
+   *
+   * @return {string}
+   */
+  static getTimestamp(): string
+
+  /**
+   * Get the timestamp diff between logs.
+   *
+   * @param {number} lastTimestamp
+   * @return {string}
+   */
+  static getTimestampDiff(lastTimestamp: number): string
+
+  /**
+   * Get the emoji by level.
+   *
+   * @param {string} level
+   * @param {string} [customEmoji]
+   * @return {string}
+   */
+  static getEmojiByLevel(level: string, customEmoji?: string): string
+
+  /**
+   * Paint the message by level.
+   *
+   * @param {string} level
+   * @param {string|any} message
+   * @return {string}
+   */
+  static paintByLevel(level: string, message: string): string
+
+  /**
+   * Group the configuration values.
+   *
+   * @param {any} object
+   * @param {any} defaultValue
+   * @return {any}
+   */
+  static groupConfigs(object: any, defaultValue: any): any
+}
+
+export class DriverFactory {
+  /**
+   * Drivers of DriverFactory.
+   *
+   * @type {Map<string, { Driver: any }>}
+   */
+  static drivers: Map<
+    string,
+    {
+      Driver: any
+    }
+  >
+
+  /**
+   * Return an array with all available drivers.
+   *
+   * @return {any[]}
+   */
+  static availableDrivers(): any[]
+
+  /**
+   * Fabricate a new instance of a driver based on
+   * channel configurations.
+   *
+   * @param {string} channelName
+   * @param {any} runtimeConfig
+   * @return {any}
+   */
+  static fabricate(channelName: string, runtimeConfig?: any): any
+
+  /**
+   * Creates a new driver implementation.
+   *
+   * @param {string} name
+   * @param {(channel: string, configs?: any) => any} driver
+   */
+  static createDriver(
+    name: string,
+    driver: (channel: string, configs?: any) => any,
+  ): void
+}
+
+export class FormatterFactory {
+  /**
+   * Formatters of FormatterFactory.
+   *
+   * @type {Map<string, { Formatter: any }>}
+   */
+  static formatters: Map<
+    string,
+    {
+      Formatter: any
+    }
+  >
+
+  /**
+   * Return an array with all available formatters.
+   *
+   * @return {any[]}
+   */
+  static availableFormatters(): any[]
+
+  /**
+   * Fabricate a new instance of a formatter.
+   *
+   * @param {string} formatterName
+   * @return {any}
+   */
+  static fabricate(formatterName: string): any
+
+  /**
+   * Creates a new formatter implementation.
+   *
+   * @param {string} name
+   * @param {() => any} formatter
+   */
+  static createFormatter(name: string, formatter: () => any): void
+}
+
+export class Logger {
+  /**
+   * Set runtime configurations for drivers and
+   * formatters.
+   *
+   * @param {any} runtimeConfig
+   * @return {Logger}
+   */
+  config(runtimeConfig: any): Logger
+
+  /**
+   * Change the log channel.
+   *
+   * @param {string[]} channels
+   * @return {Logger}
+   */
+  channel(...channels: string[]): Logger
+
+  /**
+   * Creates a log of type info in channel.
+   *
+   * @param {string|any} message
+   * @param {any} [options]
+   * @return {void | Promise<void>}
+   */
+  info(message: string | any, options?: any): void | Promise<void>
+
+  /**
+   * Creates a log of type warn in channel.
+   *
+   * @param {string|any} message
+   * @param {any} [options]
+   * @return {void | Promise<void>}
+   */
+  warn(message: string | any, options?: any): void | Promise<void>
+
+  /**
+   * Creates a log of type error in channel.
+   *
+   * @param {string|any} message
+   * @param {any} [options]
+   * @return {void | Promise<void>}
+   */
+  error(message: string | any, options?: any): void | Promise<void>
+
+  /**
+   * Creates a log of type critical in channel.
+   *
+   * @param {string|any} message
+   * @param {any} [options]
+   * @return {void | Promise<void>}
+   */
+  critical(message: string | any, options?: any): void | Promise<void>
+
+  /**
+   * Creates a log of type debug in channel.
+   *
+   * @param {string|any} message
+   * @param {any} [options]
+   * @return {void | Promise<void>}
+   */
+  debug(message: string | any, options?: any): void | Promise<void>
+
+  /**
+   * Creates a log of type success in channel.
+   *
+   * @param {string|any} message
+   * @param {any} [options]
+   * @return {void | Promise<void>}
+   */
+  success(message: string | any, options?: any): void | Promise<void>
+}

package/src/index.js

@@ -0,0 +1,269 @@
+import Chalk from 'chalk'
+
+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 './Factories/DriverFactory.js'
+export * from './Factories/FormatterFactory.js'
+
+export class Logger {
+  /**
+   * Runtime configurations to be used inside the Drivers and Formatters.
+   *
+   * @type {any}
+   */
+  #runtimeConfig = {}
+
+  /**
+   * The driver responsible for transporting the logs.
+   *
+   * @type {any[]}
+   */
+  #drivers = []
+
+  /**
+   * The log channel selected with driver and formatter configurations.
+   *
+   * @type {string[]}
+   */
+  #channelNames = []
+
+  /**
+   * Creates a new instance of Logger.
+   *
+   * @return {Logger}
+   */
+  constructor() {
+    this.#drivers.push(DriverFactory.fabricate('default', this.#runtimeConfig))
+  }
+
+  /**
+   * Return all drivers available.
+   *
+   * @return {string[]}
+   */
+  static get drivers() {
+    return DriverFactory.availableDrivers()
+  }
+
+  /**
+   * Return all formatters available.
+   *
+   * @return {string[]}
+   */
+  static get formatters() {
+    return FormatterFactory.availableFormatters()
+  }
+
+  /**
+   * Applies the log engine to execute chalk methods of string.
+   *
+   * @param {string} content
+   */
+  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))
+      }
+
+      return content
+    }
+
+    return content
+  }
+
+  /**
+   * Transport the log.
+   *
+   * @param {string|any} message
+   * @param {any} [options]
+   * @param {any} [defaultValues]
+   * @return {void | Promise<void>}
+   */
+  #log(message, options = {}, defaultValues = {}) {
+    options = this.#createOptions(options, defaultValues)
+
+    message = Logger.#applyLogEngine(message)
+
+    const promises = this.#drivers.map(d => d.transport(message, options))
+
+    return Promise.all(promises)
+  }
+
+  /**
+   * Create options concatenating client options with default options.
+   *
+   * @param {any} options
+   * @param {any} defaultValues
+   * @return {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
+  }
+
+  /**
+   * Set runtime configurations for drivers and
+   * formatters.
+   *
+   * @param {any} runtimeConfig
+   * @return {Logger}
+   */
+  config(runtimeConfig) {
+    this.#runtimeConfig = runtimeConfig
+
+    return this
+  }
+
+  /**
+   * Change the log channel.
+   *
+   * @param {string[]} channels
+   * @return {Logger}
+   */
+  channel(...channels) {
+    this.#drivers = []
+    this.#channelNames = channels
+
+    channels.forEach(channel => {
+      this.#drivers.push(DriverFactory.fabricate(channel, this.#runtimeConfig))
+    })
+
+    return this
+  }
+
+  /**
+   * Creates a log of type info in channel.
+   *
+   * @param {string|any} message
+   * @param {any} [options]
+   * @return {void | Promise<void>}
+   */
+  info(message, options = {}) {
+    return this.#log(message, options, {
+      formatterConfig: {
+        level: 'INFO',
+        chalk: ColorHelper.cyan,
+      },
+    })
+  }
+
+  /**
+   * Creates a log of type warn in channel.
+   *
+   * @param {string|any} message
+   * @param {any} [options]
+   * @return {void | Promise<void>}
+   */
+  warn(message, options = {}) {
+    return this.#log(message, options, {
+      formatterConfig: {
+        level: 'WARN',
+        chalk: ColorHelper.orange,
+      },
+    })
+  }
+
+  /**
+   * Creates a log of type error in channel.
+   *
+   * @param {string|any} message
+   * @param {any} [options]
+   * @return {void | Promise<void>}
+   */
+  error(message, options = {}) {
+    return this.#log(message, options, {
+      formatterConfig: {
+        level: 'ERROR',
+        chalk: ColorHelper.red,
+      },
+    })
+  }
+
+  /**
+   * Creates a log of type critical in channel.
+   *
+   * @param {string|any} message
+   * @param {any} [options]
+   * @return {void | Promise<void>}
+   */
+  critical(message, options = {}) {
+    return this.#log(message, options, {
+      formatterConfig: {
+        level: 'CRITICAL',
+        chalk: ColorHelper.darkRed,
+      },
+    })
+  }
+
+  /**
+   * Creates a log of type debug in channel.
+   *
+   * @param {string|any} message
+   * @param {any} [options]
+   * @return {void | Promise<void>}
+   */
+  debug(message, options = {}) {
+    return this.#log(message, options, {
+      formatterConfig: {
+        level: 'DEBUG',
+        chalk: ColorHelper.purple,
+      },
+    })
+  }
+
+  /**
+   * 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,
+      },
+    })
+  }
+}

package/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * @athenna/logger
- *
- * (c) João Lenon <lenon@athenna.io>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-export * 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

@@ -1,25 +0,0 @@
-"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-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/src/Contracts/DefaultDriverConfigs.d.ts

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

package/src/Contracts/DefaultDriverConfigs.js

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

package/src/Contracts/DriverContract.d.ts

@@ -1,13 +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 { DefaultDriverConfigs } from './DefaultDriverConfigs';
-export interface DriverContract {
-    configs?: DefaultDriverConfigs | any;
-    transport(message: string, options?: any): void | Promise<void>;
-}