@athenna/logger 1.0.4 → 1.0.7

package/index.d.ts

@@ -6,7 +6,6 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-export * from './src/Log';
 export * from './src/Logger';
 export * from './src/Contracts/DriverContract';
 export * from './src/Contracts/FormatterContract';

package/index.js

@@ -18,7 +18,6 @@ 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/Log"), exports);
 __exportStar(require("./src/Logger"), 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.0.4",
+  "version": "1.0.7",
   "description": "",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",
@@ -130,6 +130,7 @@
       "@typescript-eslint/interface-name-prefix": "off",
       "@typescript-eslint/no-explicit-any": "off",
       "prettier/prettier": "error",
+      "@typescript-eslint/no-empty-function": "off",
       "@typescript-eslint/no-unused-vars": [
         "error",
         {
@@ -152,6 +153,7 @@
     }
   },
   "dependencies": {
+    "@athenna/ioc": "1.0.9",
     "@secjs/utils": "1.8.0",
     "reflect-metadata": "0.1.13",
     "tscpaths": "0.0.9"

package/src/Drivers/ConsoleDriver.d.ts

@@ -14,12 +14,12 @@ export interface ConsoleDriverOpts {
     context: string;
     formatter: string;
     streamType: string;
+    formatterConfig: any;
 }
 export declare class ConsoleDriver implements DriverContract {
-    private readonly _level;
-    private readonly _context;
     private readonly _formatter;
     private readonly _streamType;
+    private readonly _formatterConfig;
     constructor(channel: string, configs?: any);
     transport(message: string, options?: ConsoleDriverOpts): void;
 }

package/src/Drivers/ConsoleDriver.js

@@ -14,19 +14,17 @@ const FormatterFactory_1 = require("../Factories/FormatterFactory");
 class ConsoleDriver {
     constructor(channel, configs = {}) {
         const channelConfig = utils_1.Config.get(`logging.channels.${channel}`);
-        this._level = configs.level || channelConfig.level;
-        this._context = configs.context || channelConfig.context;
         this._formatter = configs.formatter || channelConfig.formatter;
         this._streamType = configs.streamType || channelConfig.streamType;
+        this._formatterConfig =
+            configs.formatterConfig || channelConfig.formatterConfig;
     }
     transport(message, options) {
         options = Object.assign({}, {
-            level: this._level,
-            context: this._context,
             formatter: this._formatter,
             streamType: this._streamType,
         }, options);
-        message = FormatterFactory_1.FormatterFactory.fabricate(options.formatter).format(message, options);
+        message = FormatterFactory_1.FormatterFactory.fabricate(options.formatter).format(message, options.formatterConfig || this._formatterConfig);
         process[options.streamType].write(`${message}\n`);
     }
 }

package/src/Drivers/DebugDriver.d.ts

@@ -14,12 +14,12 @@ export interface DebugDriverOpts {
     context: string;
     formatter: string;
     namespace: string;
+    formatterConfig: any;
 }
 export declare class DebugDriver implements DriverContract {
-    private readonly _level;
-    private readonly _context;
     private readonly _formatter;
     private readonly _namespace;
+    private readonly _formatterConfig;
     constructor(channel: string, configs?: any);
     transport(message: string, options?: DebugDriverOpts): void;
 }

package/src/Drivers/DebugDriver.js

@@ -15,19 +15,17 @@ const FormatterFactory_1 = require("../Factories/FormatterFactory");
 class DebugDriver {
     constructor(channel, configs = {}) {
         const channelConfig = utils_1.Config.get(`logging.channels.${channel}`);
-        this._level = configs.level || channelConfig.level;
-        this._context = configs.context || channelConfig.context;
         this._formatter = configs.formatter || channelConfig.formatter;
         this._namespace = configs.namespace || channelConfig.namespace;
+        this._formatterConfig =
+            configs.formatterConfig || channelConfig.formatterConfig;
     }
     transport(message, options) {
         options = Object.assign({}, {
-            level: this._level,
-            context: this._context,
             formatter: this._formatter,
             namespace: this._namespace,
         }, options);
-        message = FormatterFactory_1.FormatterFactory.fabricate(options.formatter).format(message, options);
+        message = FormatterFactory_1.FormatterFactory.fabricate(options.formatter).format(message, options.formatterConfig || this._formatterConfig);
         debug_1.debug(options.namespace)(message);
     }
 }

package/src/Drivers/FileDriver.d.ts

@@ -12,12 +12,12 @@ export interface FileDriverOpts {
     context: string;
     formatter: string;
     filePath: string;
+    formatterConfig: any;
 }
 export declare class FileDriver implements DriverContract {
-    private readonly _level;
-    private readonly _context;
     private readonly _filePath;
     private readonly _formatter;
+    private readonly _formatterConfig;
     constructor(channel: string, configs?: any);
     transport(message: string, options?: FileDriverOpts): Promise<void>;
 }

package/src/Drivers/FileDriver.js

@@ -17,15 +17,13 @@ const FormatterFactory_1 = require("../Factories/FormatterFactory");
 class FileDriver {
     constructor(channel, configs = {}) {
         const channelConfig = utils_1.Config.get(`logging.channels.${channel}`);
-        this._level = configs.level || channelConfig.level;
-        this._context = configs.context || channelConfig.context;
         this._filePath = configs.filePath || channelConfig.filePath;
         this._formatter = configs.formatter || channelConfig.formatter;
+        this._formatterConfig =
+            configs.formatterConfig || channelConfig.formatterConfig;
     }
     async transport(message, options) {
         options = Object.assign({}, {
-            level: this._level,
-            context: this._context,
             filePath: this._filePath,
             formatter: this._formatter,
         }, options);
@@ -34,7 +32,7 @@ class FileDriver {
         if (!fs_1.existsSync(dir)) {
             fs_1.mkdirSync(dir, { recursive: true });
         }
-        message = FormatterFactory_1.FormatterFactory.fabricate(options.formatter).format(message, options);
+        message = FormatterFactory_1.FormatterFactory.fabricate(options.formatter).format(message, options.formatterConfig || this._formatterConfig);
         return new Promise((resolve, reject) => {
             const stream = fs_1.createWriteStream(filePath, { flags: 'a' });
             stream.write(`${Color_1.Color.removeColors(message)}` + '\n');

package/src/Logger.d.ts

@@ -4,16 +4,17 @@ export declare class Logger {
     private runtimeConfig;
     private channelName;
     private driver;
-    static buildDriver(name: string, driver: new (channel: string, configs?: any) => DriverContract): void;
-    static buildFormatter(name: string, formatter: new () => FormatterContract): void;
+    constructor(runtimeConfig?: any);
     static get drivers(): string[];
     static get formatters(): string[];
-    constructor(runtimeConfig?: any);
+    static buildDriver(name: string, driver: new (channel: string, configs?: any) => DriverContract): void;
+    static buildFormatter(name: string, formatter: new () => FormatterContract): void;
     channel(channel: string, runtimeConfig?: any): Logger;
-    log(message: any, options?: any): Promise<void>;
-    info(message: any, options?: any): Promise<void>;
-    warn(message: any, options?: any): Promise<void>;
-    error(message: any, options?: any): Promise<void>;
-    debug(message: any, options?: any): Promise<void>;
-    success(message: any, options?: any): Promise<void>;
+    log(message: any, options?: {}): void | Promise<void>;
+    info(message: any, options?: {}): void | Promise<void>;
+    warn(message: any, options?: {}): void | Promise<void>;
+    error(message: any, options?: {}): void | Promise<void>;
+    debug(message: any, options?: {}): void | Promise<void>;
+    success(message: any, options?: {}): void | Promise<void>;
+    private createOptions;
 }

package/src/Logger.js

@@ -12,98 +12,98 @@ class Logger {
         this.channelName = 'default';
         this.driver = DriverFactory_1.DriverFactory.fabricate(this.channelName, this.runtimeConfig);
     }
-    static buildDriver(name, driver) {
-        DriverFactory_1.DriverFactory.createDriver(name, driver);
-    }
-    static buildFormatter(name, formatter) {
-        FormatterFactory_1.FormatterFactory.createFormatter(name, formatter);
-    }
     static get drivers() {
         return DriverFactory_1.DriverFactory.availableDrivers();
     }
     static get formatters() {
         return FormatterFactory_1.FormatterFactory.availableFormatters();
     }
+    static buildDriver(name, driver) {
+        DriverFactory_1.DriverFactory.createDriver(name, driver);
+    }
+    static buildFormatter(name, formatter) {
+        FormatterFactory_1.FormatterFactory.createFormatter(name, formatter);
+    }
     channel(channel, runtimeConfig) {
         if (runtimeConfig)
             this.runtimeConfig = runtimeConfig;
         this.driver = DriverFactory_1.DriverFactory.fabricate(channel, this.runtimeConfig);
         return this;
     }
-    async log(message, options) {
-        options = Object.assign({}, { context: 'Logger' }, options);
-        if (this.runtimeConfig && this.runtimeConfig.formatterConfig) {
-            options = {
-                ...options,
-                ...this.runtimeConfig.formatterConfig,
-            };
-        }
-        await this.driver.transport(message, options);
+    log(message, options = {}) {
+        options = this.createOptions(options, {
+            streamType: 'stdout',
+        });
+        return this.driver.transport(message, options);
     }
-    async info(message, options) {
-        options = Object.assign({}, { context: 'Logger' }, options);
-        options.level = 'INFO';
-        options.color = Color_1.Color.cyan;
-        options.streamType = 'stdout';
-        if (this.runtimeConfig && this.runtimeConfig.formatterConfig) {
-            options = {
-                ...options,
-                ...this.runtimeConfig.formatterConfig,
-            };
-        }
-        await this.driver.transport(message, options);
+    info(message, options = {}) {
+        options = this.createOptions(options, {
+            streamType: 'stdout',
+            formatterConfig: {
+                level: 'INFO',
+                color: Color_1.Color.cyan,
+            },
+        });
+        return this.driver.transport(message, options);
     }
-    async warn(message, options) {
-        options = Object.assign({}, { context: 'Logger' }, options);
-        options.level = 'WARN';
-        options.color = Color_1.Color.orange;
-        options.streamType = 'stdout';
-        if (this.runtimeConfig && this.runtimeConfig.formatterConfig) {
-            options = {
-                ...options,
-                ...this.runtimeConfig.formatterConfig,
-            };
-        }
-        await this.driver.transport(message, options);
+    warn(message, options = {}) {
+        options = this.createOptions(options, {
+            streamType: 'stdout',
+            formatterConfig: {
+                level: 'WARN',
+                color: Color_1.Color.orange,
+            },
+        });
+        return this.driver.transport(message, options);
     }
-    async error(message, options) {
-        options = Object.assign({}, { context: 'Logger' }, options);
-        options.level = 'ERROR';
-        options.color = Color_1.Color.red;
-        options.streamType = 'stderr';
-        if (this.runtimeConfig && this.runtimeConfig.formatterConfig) {
-            options = {
-                ...options,
-                ...this.runtimeConfig.formatterConfig,
-            };
-        }
-        await this.driver.transport(message, options);
+    error(message, options = {}) {
+        options = this.createOptions(options, {
+            streamType: 'stdout',
+            formatterConfig: {
+                level: 'ERROR',
+                color: Color_1.Color.red,
+            },
+        });
+        return this.driver.transport(message, options);
     }
-    async debug(message, options) {
-        options = Object.assign({}, { context: 'Logger' }, options);
-        options.level = 'DEBUG';
-        options.color = Color_1.Color.purple;
-        options.streamType = 'stdout';
-        if (this.runtimeConfig && this.runtimeConfig.formatterConfig) {
-            options = {
-                ...options,
-                ...this.runtimeConfig.formatterConfig,
-            };
-        }
-        await this.driver.transport(message, options);
+    debug(message, options = {}) {
+        options = this.createOptions(options, {
+            streamType: 'stdout',
+            formatterConfig: {
+                level: 'DEBUG',
+                color: Color_1.Color.purple,
+            },
+        });
+        return this.driver.transport(message, options);
+    }
+    success(message, options = {}) {
+        options = this.createOptions(options, {
+            streamType: 'stdout',
+            formatterConfig: {
+                level: 'SUCCESS',
+                color: Color_1.Color.green,
+            },
+        });
+        return this.driver.transport(message, options);
     }
-    async success(message, options) {
-        options = Object.assign({}, { context: 'Logger' }, options);
-        options.level = 'SUCCESS';
-        options.color = Color_1.Color.green;
-        options.streamType = 'stdout';
-        if (this.runtimeConfig && this.runtimeConfig.formatterConfig) {
-            options = {
-                ...options,
+    createOptions(options, defaultValues) {
+        let formatterConfig = Object.assign({}, {
+            ...defaultValues.formatterConfig,
+        }, options.formatterConfig);
+        if (this.runtimeConfig.formatterConfig) {
+            formatterConfig = {
                 ...this.runtimeConfig.formatterConfig,
+                ...formatterConfig,
             };
         }
-        await this.driver.transport(message, options);
+        options = Object.assign({}, {
+            streamType: 'stdout',
+        }, options);
+        options = {
+            ...options,
+            formatterConfig,
+        };
+        return options;
     }
 }
 exports.Logger = Logger;

package/src/Providers/LoggerProvider.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @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 { ServiceProvider } from '@athenna/ioc';
+export declare class LoggerProvider extends ServiceProvider {
+    /**
+     * Register any application services.
+     *
+     * @return void
+     */
+    register(): void;
+}

package/src/Providers/LoggerProvider.js

@@ -0,0 +1,24 @@
+"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.LoggerProvider = void 0;
+const Logger_1 = require("../Logger");
+const ioc_1 = require("@athenna/ioc");
+class LoggerProvider extends ioc_1.ServiceProvider {
+    /**
+     * Register any application services.
+     *
+     * @return void
+     */
+    register() {
+        this.container.bind('Athenna/Core/Logger', Logger_1.Logger);
+    }
+}
+exports.LoggerProvider = LoggerProvider;

package/src/Log.d.ts

@@ -1,18 +0,0 @@
-import { DriverContract } from './Contracts/DriverContract';
-import { FormatterContract } from './Contracts/FormatterContract';
-export declare class Log {
-    private static _options?;
-    private static logger;
-    static options(options?: any): void;
-    static buildDriver(name: string, driver: new (channel: string, configs?: any) => DriverContract): typeof Log;
-    static buildFormatter(name: string, formatter: new () => FormatterContract): typeof Log;
-    static get drivers(): string[];
-    static get formatters(): string[];
-    static channel(channel: string): typeof Log;
-    static log(message: any, options?: any): void;
-    static info(message: any, options?: any): void;
-    static warn(message: any, options?: any): void;
-    static error(message: any, options?: any): void;
-    static debug(message: any, options?: any): void;
-    static success(message: any, options?: any): void;
-}

package/src/Log.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Log = void 0;
-const Logger_1 = require("./Logger");
-class Log {
-    static options(options) {
-        this._options = options;
-    }
-    static buildDriver(name, driver) {
-        Logger_1.Logger.buildDriver(name, driver);
-        return this;
-    }
-    static buildFormatter(name, formatter) {
-        Logger_1.Logger.buildFormatter(name, formatter);
-        return this;
-    }
-    static get drivers() {
-        return Logger_1.Logger.drivers;
-    }
-    static get formatters() {
-        return Logger_1.Logger.formatters;
-    }
-    static channel(channel) {
-        if (!this.logger)
-            this.logger = new Logger_1.Logger();
-        this.logger.channel(channel);
-        return this;
-    }
-    static log(message, options) {
-        options = {
-            ...options,
-            ...this._options,
-        };
-        this.logger.log(message, options);
-        this.logger = new Logger_1.Logger();
-    }
-    static info(message, options) {
-        options = {
-            ...options,
-            ...this._options,
-        };
-        this.logger.info(message, options);
-        this.logger = new Logger_1.Logger();
-    }
-    static warn(message, options) {
-        options = {
-            ...options,
-            ...this._options,
-        };
-        this.logger.warn(message, options);
-        this.logger = new Logger_1.Logger();
-    }
-    static error(message, options) {
-        options = {
-            ...options,
-            ...this._options,
-        };
-        this.logger.error(message, options);
-        this.logger = new Logger_1.Logger();
-    }
-    static debug(message, options) {
-        options = {
-            ...options,
-            ...this._options,
-        };
-        this.logger.debug(message, options);
-        this.logger = new Logger_1.Logger();
-    }
-    static success(message, options) {
-        options = {
-            ...options,
-            ...this._options,
-        };
-        this.logger.success(message, options);
-        this.logger = new Logger_1.Logger();
-    }
-}
-exports.Log = Log;
-Log._options = {};

package/src/Utils/global.d.ts

@@ -1,15 +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 { Log as LogFunction } from '../Log';
-import { Logger as LoggerClass } from '../Logger';
-export {};
-declare global {
-    const Log: typeof LogFunction;
-    const Logger: typeof LoggerClass;
-}

package/src/Utils/global.js

@@ -1,15 +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.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const Log_1 = require("../Log");
-const Logger_1 = require("../Logger");
-const _global = global;
-_global.Log = Log_1.Log;
-_global.Logger = Logger_1.Logger;