just-enough-logger/dist/just-enough-logger.esm.js

Minimal logger for nodejs

import { parse, resolve } from 'path';
import { existsSync, mkdirSync, openSync, createWriteStream } from 'fs';
import { yellow, red } from 'colors';

function _extends() {
  _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];

      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }

    return target;
  };

  return _extends.apply(this, arguments);
}

/**
 * Logger class
 *
 * @class Logger
 * @implements {ILogger}
 */

var Logger =
/*#__PURE__*/
function () {
  /**
   * Creates an instance of Logger
   * @param {ILoggerOptions} [options]
   * @memberof Logger
   */
  function Logger(options) {
    this.options = {
      transports: ["file", "console"],
      file: resolve(process.cwd(), "log.log"),
      formatter: this.__formatter
    };
    this.__fileStream = null;
    this.options = _extends({}, this.options, {}, options);

    if (this.__shouldWriteToFile()) {
      this.__createLogFile();

      this.__fileStream = createWriteStream(this.options.file, {
        flags: "a"
      });
    }
  }
  /**
   * Prints message with INFO level
   *
   * @param {string} message
   * @memberof Logger
   */


  var _proto = Logger.prototype;

  _proto.info = function info(message) {
    this.__write(message, "info");
  }
  /**
   * Prints message with WARN level
   *
   * @param {string} message
   * @memberof Logger
   */
  ;

  _proto.warn = function warn(message) {
    this.__write(message, "warn");
  }
  /**
   * Prints message with ERROR level
   *
   * @param {string} message
   * @memberof Logger
   */
  ;

  _proto.error = function error(message) {
    this.__write(message, "error");
  }
  /**
   * Creates log message with custom format. Default is: `new Date().toLocaleString() : [LEVEL] : message`
   *
   * @param {string} message
   * @param {Level} level
   * @returns {string} The output message
   * @memberof Logger
   */
  ;

  _proto.__formatter = function __formatter(message, level) {
    return new Date().toLocaleString() + " : [" + level.toUpperCase() + "] : " + message;
  }
  /**
   * Checks if file transport is selected
   *
   * @private
   * @returns {boolean}
   * @memberof Logger
   */
  ;

  _proto.__shouldWriteToFile = function __shouldWriteToFile() {
    return this.options.transports.indexOf("file") > -1;
  }
  /**
   * Checks if console transport is selected
   *
   * @private
   * @returns {boolean}
   * @memberof Logger
   */
  ;

  _proto.__shouldWriteToConsole = function __shouldWriteToConsole() {
    return this.options.transports.indexOf("console") > -1;
  }
  /**
   * Creates log file if it doesn't exist
   *
   * @private
   * @memberof Logger
   */
  ;

  _proto.__createLogFile = function __createLogFile() {
    var file = this.options.file;

    if (file) {
      var _parse = parse(file),
          dir = _parse.dir;

      if (!existsSync(dir)) {
        mkdirSync(dir);
      }

      if (!existsSync(file)) {
        openSync(file, "w");
      }
    }
  }
  /**
   * Writes log message to file
   *
   * @private
   * @param {string} message
   * @memberof Logger
   */
  ;

  _proto.__writeToFile = function __writeToFile(message) {
    var file = this.options.file;

    if (file && this.__fileStream) {
      this.__fileStream.write(message + "\n");
    }
  }
  /**
   * Writes log message to console
   *
   * @private
   * @param {string} message
   * @param {Level} level
   * @memberof Logger
   */
  ;

  _proto.__writeToConsole = function __writeToConsole(message, level) {
    switch (level) {
      case "warn":
        console[level](yellow(message));
        break;

      case "error":
        console[level](red(message));
        break;

      case "info":
        console[level](message);
        break;
    }
  }
  /**
   * Calls appropriate method to write formatted message
   *
   * @private
   * @param {string} message
   * @param {Level} level
   * @memberof Logger
   */
  ;

  _proto.__write = function __write(message, level) {
    var formatter = this.options.formatter;

    if (formatter) {
      var formattedMessage = formatter(message, level);

      if (this.__shouldWriteToConsole()) {
        this.__writeToConsole(formattedMessage, level);
      }

      if (this.__shouldWriteToFile()) {
        this.__writeToFile(formattedMessage);
      }
    }
  }
  /**
   * Returns the log file path for this logger instance.
   *
   * @returns {string} Path of log file.
   * @memberof Logger
   */
  ;

  _proto.getLogFilePath = function getLogFilePath() {
    var file = this.options.file;

    if (file) {
      return resolve(file);
    }

    return null;
  }
  /**
   * Returns the file stream of the log file or null if no file transport available.
   *
   * @returns {WritableStream}
   * @memberof Logger
   */
  ;

  _proto.getLogStream = function getLogStream() {
    return this.__fileStream;
  };

  return Logger;
}(); // Keep default export for backward compatibility.

export default Logger;
export { Logger };
//# sourceMappingURL=just-enough-logger.esm.js.map