@athenna/logger 1.0.0

package/src/Factories/DriverFactory.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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 { DriverContract } from '../Contracts/DriverContract';
+export interface DriverObject {
+    Driver: any;
+}
+export declare class DriverFactory {
+    private static drivers;
+    static availableDrivers(): string[];
+    static fabricate(channelName: string, runtimeConfig?: any): DriverContract;
+    static createDriver(name: string, driver: new (channel: string, configs?: any) => DriverContract): void;
+    private static getChannelConfig;
+}

package/src/Factories/DriverFactory.js

@@ -0,0 +1,59 @@
+"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.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;
+    }
+    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);
+    }
+    static createDriver(name, driver) {
+        if (this.drivers.has(name)) {
+            throw new DriverAlreadyExistException_1.DriverAlreadyExistException(name);
+        }
+        this.drivers.set(name, { Driver: 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;
+    }
+}
+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 });

package/src/Factories/FormatterFactory.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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 { FormatterContract } from '../Contracts/FormatterContract';
+export interface FormatterObject {
+    Formatter: any;
+}
+export declare class FormatterFactory {
+    private static formatters;
+    static availableFormatters(): string[];
+    static fabricate(formatterName: string): FormatterContract;
+    static createFormatter(name: string, driver: new () => FormatterContract): void;
+}

package/src/Factories/FormatterFactory.js

@@ -0,0 +1,45 @@
+"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.FormatterFactory = void 0;
+const LogFormatter_1 = require("../Formatters/LogFormatter");
+const JsonFormatter_1 = require("../Formatters/JsonFormatter");
+const DebugFormatter_1 = require("../Formatters/DebugFormatter");
+const ContextFormatter_1 = require("../Formatters/ContextFormatter");
+const NotFoundFormatterException_1 = require("../Exceptions/NotFoundFormatterException");
+const FormatterAlreadyExistException_1 = require("../Exceptions/FormatterAlreadyExistException");
+class FormatterFactory {
+    static availableFormatters() {
+        const availableFormatters = [];
+        for (const [key] of this.formatters.entries()) {
+            availableFormatters.push(key);
+        }
+        return availableFormatters;
+    }
+    static fabricate(formatterName) {
+        const formatterObject = this.formatters.get(formatterName);
+        if (!formatterObject) {
+            throw new NotFoundFormatterException_1.NotFoundFormatterException(formatterName);
+        }
+        return new formatterObject.Formatter();
+    }
+    static createFormatter(name, driver) {
+        if (this.formatters.has(name)) {
+            throw new FormatterAlreadyExistException_1.FormatterAlreadyExistException(name);
+        }
+        this.formatters.set(name, { Formatter: driver });
+    }
+}
+exports.FormatterFactory = FormatterFactory;
+FormatterFactory.formatters = new Map()
+    .set('context', { Formatter: ContextFormatter_1.ContextFormatter })
+    .set('debug', { Formatter: DebugFormatter_1.DebugFormatter })
+    .set('json', { Formatter: JsonFormatter_1.JsonFormatter })
+    .set('log', { Formatter: LogFormatter_1.LogFormatter });

package/src/Formatters/ContextFormatter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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 { Chalk } from 'chalk';
+import { FormatterContract } from '../Contracts/FormatterContract';
+export interface ContextFormatterOptions {
+    color: Chalk;
+    context: string;
+}
+export declare class ContextFormatter implements FormatterContract {
+    format(message: string, options?: ContextFormatterOptions): string;
+    private static lastTimestamp?;
+    private static getTimestampDiff;
+}

package/src/Formatters/ContextFormatter.js

@@ -0,0 +1,32 @@
+"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.ContextFormatter = void 0;
+const Color_1 = require("../Utils/Color");
+const getTimestamp_1 = require("../Utils/getTimestamp");
+class ContextFormatter {
+    format(message, options) {
+        options = Object.assign({}, { color: Color_1.Color.green, context: 'Logger' }, options);
+        const pid = Color_1.Color.darkPurple(`[Athenna] - PID: ${process.pid}`);
+        const timestamp = getTimestamp_1.getTimestamp();
+        const messageCtx = Color_1.Color.yellow(`[${options.context}] `);
+        const timestampDiff = ContextFormatter.getTimestampDiff();
+        return `${pid} - ${timestamp} ${messageCtx}${options.color(message)}${timestampDiff}`;
+    }
+    static getTimestampDiff() {
+        let result = '';
+        if (this.lastTimestamp) {
+            result = Color_1.Color.yellow(` +${Date.now() - this.lastTimestamp}ms`);
+        }
+        this.lastTimestamp = Date.now();
+        return result;
+    }
+}
+exports.ContextFormatter = ContextFormatter;

package/src/Formatters/DebugFormatter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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 { Chalk } from 'chalk';
+import { FormatterContract } from '../Contracts/FormatterContract';
+export interface DebugFormatterOptions {
+    color: Chalk;
+    context: string;
+    namespace: string;
+}
+export declare class DebugFormatter implements FormatterContract {
+    format(message: string, options?: DebugFormatterOptions): string;
+    private static lastTimestamp?;
+    private static getTimestampDiff;
+}

package/src/Formatters/DebugFormatter.js

@@ -0,0 +1,32 @@
+"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.DebugFormatter = void 0;
+const Color_1 = require("../Utils/Color");
+const getTimestamp_1 = require("../Utils/getTimestamp");
+class DebugFormatter {
+    format(message, options) {
+        options = Object.assign({}, { color: Color_1.Color.green, context: 'Debugger', namespace: 'api:main' }, options);
+        const pid = Color_1.Color.purple(`[Athenna Debugger] - PID: ${process.pid}`);
+        const timestamp = Color_1.Color.white(getTimestamp_1.getTimestamp());
+        const messageCtx = Color_1.Color.yellow(`[${options.context}] `);
+        const timestampDiff = DebugFormatter.getTimestampDiff();
+        return `${pid} - ${timestamp} ${messageCtx}${options.color(message)}${timestampDiff}`;
+    }
+    static getTimestampDiff() {
+        let result = '';
+        if (this.lastTimestamp) {
+            result = Color_1.Color.yellow(` +${Date.now() - this.lastTimestamp}ms`);
+        }
+        this.lastTimestamp = Date.now();
+        return result;
+    }
+}
+exports.DebugFormatter = DebugFormatter;

package/src/Formatters/JsonFormatter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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 { Chalk } from 'chalk';
+import { FormatterContract } from '../Contracts/FormatterContract';
+export interface JsonFormatterOptions {
+    color: Chalk;
+}
+export declare class JsonFormatter implements FormatterContract {
+    format(message: Record<any, unknown>, options?: JsonFormatterOptions): string;
+}

package/src/Formatters/JsonFormatter.js

@@ -0,0 +1,20 @@
+"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.JsonFormatter = void 0;
+const Color_1 = require("../Utils/Color");
+class JsonFormatter {
+    format(message, options) {
+        options = Object.assign({}, { color: Color_1.Color.green }, options);
+        const pid = Color_1.Color.yellow(`[Athenna] - PID: ${process.pid}`);
+        return `${pid} - ${Color_1.Color.bold('JSON:')} ${options.color(JSON.stringify(message))}`;
+    }
+}
+exports.JsonFormatter = JsonFormatter;

package/src/Formatters/LogFormatter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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 { Chalk } from 'chalk';
+import { FormatterContract } from '../Contracts/FormatterContract';
+export interface LogFormatterOptions {
+    color: Chalk;
+    level: 'INFO' | 'DEBUG' | 'WARN' | 'ERROR' | 'SUCCESS';
+}
+export declare class LogFormatter implements FormatterContract {
+    format(message: string, options?: LogFormatterOptions): string;
+    private static paintByLevel;
+}

package/src/Formatters/LogFormatter.js

@@ -0,0 +1,33 @@
+"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.LogFormatter = void 0;
+const Color_1 = require("../Utils/Color");
+const getTimestamp_1 = require("../Utils/getTimestamp");
+class LogFormatter {
+    format(message, options) {
+        options = Object.assign({}, { color: Color_1.Color.green, level: 'info' }, options);
+        const pid = Color_1.Color.yellow(`[Athenna] - PID: ${process.pid}`);
+        const timestamp = getTimestamp_1.getTimestamp();
+        const level = LogFormatter.paintByLevel(options.level);
+        return `${pid} - ${timestamp} ${level} ${options.color(message)}`;
+    }
+    static paintByLevel(level) {
+        const levelColors = {
+            info: Color_1.Color.info,
+            debug: Color_1.Color.debug,
+            warn: Color_1.Color.warning,
+            error: Color_1.Color.error,
+            success: Color_1.Color.log,
+        };
+        return levelColors[level.toLowerCase()](`[${level}]`);
+    }
+}
+exports.LogFormatter = LogFormatter;

package/src/Log.d.ts

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,79 @@
+"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/Logger.d.ts

@@ -0,0 +1,19 @@
+import { DriverContract } from './Contracts/DriverContract';
+import { FormatterContract } from './Contracts/FormatterContract';
+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;
+    static get drivers(): string[];
+    static get formatters(): string[];
+    constructor(runtimeConfig?: any);
+    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>;
+}

package/src/Logger.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const Color_1 = require("./Utils/Color");
+const utils_1 = require("@secjs/utils");
+const DriverFactory_1 = require("./Factories/DriverFactory");
+const FormatterFactory_1 = require("./Factories/FormatterFactory");
+class Logger {
+    constructor(runtimeConfig = {}) {
+        new utils_1.Config().safeLoad(utils_1.Path.config('logging'));
+        this.runtimeConfig = runtimeConfig;
+        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();
+    }
+    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);
+        await 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';
+        await 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';
+        await 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';
+        await 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';
+        await 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';
+        await this.driver.transport(message, options);
+    }
+}
+exports.Logger = Logger;

package/src/Utils/Color.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @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 { Chalk } from 'chalk';
+declare type Methods = 'GET' | 'POST' | 'PUT' | 'DELETE';
+export declare class Color {
+    static chalk: Chalk & {
+        supportsColor: import("chalk").ColorSupport;
+    };
+    static get bold(): Chalk;
+    static get purple(): Chalk;
+    static get darkPurple(): Chalk;
+    static get yellow(): Chalk;
+    static get cyan(): Chalk;
+    static get white(): Chalk;
+    static get orange(): Chalk;
+    static get green(): Chalk;
+    static get darkGreen(): Chalk;
+    static get red(): Chalk;
+    static removeColors(string: string): any;
+    static get info(): any;
+    static get log(): any;
+    static get debug(): any;
+    static get error(): any;
+    static get warning(): any;
+    static httpMethod(method: Methods): any;
+    static get GET(): any;
+    static get PUT(): any;
+    static get POST(): any;
+    static get DELETE(): any;
+}
+export {};

package/src/Utils/Color.js

@@ -0,0 +1,84 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+class Color {
+    static get bold() {
+        return Color.chalk.bold;
+    }
+    static get purple() {
+        return Color.chalk.hex('#7628c8');
+    }
+    static get darkPurple() {
+        return Color.chalk.hex('#501b86');
+    }
+    static get yellow() {
+        return Color.chalk.hex('#ffe600');
+    }
+    static get cyan() {
+        return Color.chalk.hex('#00ffff');
+    }
+    static get white() {
+        return Color.chalk.hex('#ffffff');
+    }
+    static get orange() {
+        return Color.chalk.hex('#f18b0e');
+    }
+    static get green() {
+        return Color.chalk.hex('#0ef12c');
+    }
+    static get darkGreen() {
+        return Color.chalk.hex('#1cb70b');
+    }
+    static get red() {
+        return Color.chalk.hex('#f10e0e');
+    }
+    static removeColors(string) {
+        return Color.chalk.reset(string).replace(
+        // eslint-disable-next-line no-control-regex
+        /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+    }
+    static get info() {
+        return this.cyan.bold;
+    }
+    static get log() {
+        return this.green.bold;
+    }
+    static get debug() {
+        return this.purple.bold;
+    }
+    static get error() {
+        return this.red.bold;
+    }
+    static get warning() {
+        return this.orange.bold;
+    }
+    static httpMethod(method) {
+        return this[method];
+    }
+    static get GET() {
+        return this.purple.bold('GET 🔍');
+    }
+    static get PUT() {
+        return this.yellow.bold('PUT 🛠');
+    }
+    static get POST() {
+        return this.green.bold('POST 🧱');
+    }
+    static get DELETE() {
+        return this.red.bold('DELETE ❌');
+    }
+}
+exports.Color = Color;
+Color.chalk = chalk_1.default;

package/src/Utils/getTimestamp.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @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 declare function getTimestamp(): string;