@venok/core 1.0.0

package/services/console.service.d.ts

@@ -0,0 +1,86 @@
+import { LoggerService, LogLevel } from "@venok/core/services/logger.service";
+export interface ConsoleLoggerOptions {
+    /**
+     * Enabled log levels.
+     */
+    logLevels?: LogLevel[];
+    /**
+     * If enabled, will print timestamp (time difference) between current and previous log message.
+     */
+    timestamp?: boolean;
+}
+export declare class ConsoleLogger implements LoggerService {
+    protected context?: string | undefined;
+    protected options: ConsoleLoggerOptions;
+    private static lastTimestampAt?;
+    private originalContext?;
+    constructor();
+    constructor(context: string);
+    constructor(context: string, options: ConsoleLoggerOptions);
+    /**
+     * Write a 'log' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    log(message: any, context?: string): void;
+    log(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write an 'error' level log, if the configured level allows for it.
+     * Prints to `stderr` with newline.
+     */
+    error(message: any, stackOrContext?: string): void;
+    error(message: any, stack?: string, context?: string): void;
+    error(message: any, ...optionalParams: [...any, string?, string?]): void;
+    /**
+     * Write a 'warn' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    warn(message: any, context?: string): void;
+    warn(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'debug' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    debug(message: any, context?: string): void;
+    debug(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'verbose' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    verbose(message: any, context?: string): void;
+    verbose(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'fatal' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    fatal(message: any, context?: string): void;
+    fatal(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Set log levels
+     * @param levels log levels
+     */
+    setLogLevels(levels: LogLevel[]): void;
+    /**
+     * Set logger context
+     * @param context context
+     */
+    setContext(context: string): void;
+    /**
+     * Resets the logger context to the value that was passed in the constructor.
+     */
+    resetContext(): void;
+    isLevelEnabled(level: LogLevel): boolean;
+    protected getTimestamp(): string;
+    protected printMessages(messages: unknown[], context?: string, logLevel?: LogLevel, writeStreamType?: "stdout" | "stderr"): void;
+    protected formatPid(pid: number): string;
+    protected formatContext(context: string): string;
+    protected formatMessage(logLevel: LogLevel, message: unknown, pidMessage: string, formattedLogLevel: string, contextMessage: string, timestampDiff: string): string;
+    protected stringifyMessage(message: unknown, logLevel: LogLevel): string;
+    protected colorize(message: string, logLevel: LogLevel): string;
+    protected printStackTrace(stack: string): void;
+    protected updateAndGetTimestampDiff(): string;
+    protected formatTimestampDiff(timestampDiff: number): string;
+    private getContextAndMessagesToPrint;
+    private getContextAndStackAndMessagesToPrint;
+    private isStackFormat;
+    private getColorByLogLevel;
+}

package/services/console.service.js

@@ -0,0 +1,233 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var ConsoleLogger_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = void 0;
+const logger_service_1 = require("@venok/core/services/logger.service");
+const injectable_decorator_1 = require("@venok/core/decorators/injectable.decorator");
+const optional_decorator_1 = require("@venok/core/decorators/optional.decorator");
+const color_helper_1 = require("@venok/core/helpers/color.helper");
+const shared_helper_1 = require("@venok/core/helpers/shared.helper");
+const DEFAULT_LOG_LEVELS = ["log", "error", "warn", "debug", "verbose", "fatal"];
+const dateTimeFormatter = new Intl.DateTimeFormat(undefined, {
+    year: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric",
+    day: "2-digit",
+    month: "2-digit",
+});
+let ConsoleLogger = ConsoleLogger_1 = class ConsoleLogger {
+    constructor(context, options = {}) {
+        this.context = context;
+        this.options = options;
+        if (!options.logLevels) {
+            options.logLevels = DEFAULT_LOG_LEVELS;
+        }
+        if (context) {
+            this.originalContext = context;
+        }
+    }
+    log(message, ...optionalParams) {
+        if (!this.isLevelEnabled("log")) {
+            return;
+        }
+        const { messages, context } = this.getContextAndMessagesToPrint([message, ...optionalParams]);
+        this.printMessages(messages, context, "log");
+    }
+    error(message, ...optionalParams) {
+        if (!this.isLevelEnabled("error")) {
+            return;
+        }
+        const { messages, context, stack } = this.getContextAndStackAndMessagesToPrint([message, ...optionalParams]);
+        this.printMessages(messages, context, "error", "stderr");
+        if ((0, shared_helper_1.isUndefined)(stack))
+            return false;
+        this.printStackTrace(stack);
+    }
+    warn(message, ...optionalParams) {
+        if (!this.isLevelEnabled("warn")) {
+            return;
+        }
+        const { messages, context } = this.getContextAndMessagesToPrint([message, ...optionalParams]);
+        this.printMessages(messages, context, "warn");
+    }
+    debug(message, ...optionalParams) {
+        if (!this.isLevelEnabled("debug")) {
+            return;
+        }
+        const { messages, context } = this.getContextAndMessagesToPrint([message, ...optionalParams]);
+        this.printMessages(messages, context, "debug");
+    }
+    verbose(message, ...optionalParams) {
+        if (!this.isLevelEnabled("verbose")) {
+            return;
+        }
+        const { messages, context } = this.getContextAndMessagesToPrint([message, ...optionalParams]);
+        this.printMessages(messages, context, "verbose");
+    }
+    fatal(message, ...optionalParams) {
+        if (!this.isLevelEnabled("fatal")) {
+            return;
+        }
+        const { messages, context } = this.getContextAndMessagesToPrint([message, ...optionalParams]);
+        this.printMessages(messages, context, "fatal");
+    }
+    /**
+     * Set log levels
+     * @param levels log levels
+     */
+    setLogLevels(levels) {
+        if (!this.options) {
+            this.options = {};
+        }
+        this.options.logLevels = levels;
+    }
+    /**
+     * Set logger context
+     * @param context context
+     */
+    setContext(context) {
+        this.context = context;
+    }
+    /**
+     * Resets the logger context to the value that was passed in the constructor.
+     */
+    resetContext() {
+        this.context = this.originalContext;
+    }
+    isLevelEnabled(level) {
+        const logLevels = this.options?.logLevels;
+        return (0, logger_service_1.isLogLevelEnabled)(level, logLevels);
+    }
+    getTimestamp() {
+        return dateTimeFormatter.format(Date.now());
+    }
+    printMessages(messages, context = "", logLevel = "log", writeStreamType) {
+        messages.forEach((message) => {
+            const pidMessage = this.formatPid(process.pid);
+            const contextMessage = this.formatContext(context);
+            const timestampDiff = this.updateAndGetTimestampDiff();
+            const formattedLogLevel = logLevel.toUpperCase().padStart(7, " ");
+            const formattedMessage = this.formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff);
+            process[writeStreamType ?? "stdout"].write(formattedMessage);
+        });
+    }
+    formatPid(pid) {
+        return `[Venok] ${pid}  - `;
+    }
+    formatContext(context) {
+        return context ? (0, color_helper_1.yellow)(`[${context}] `) : "";
+    }
+    formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff) {
+        const output = this.stringifyMessage(message, logLevel);
+        pidMessage = this.colorize(pidMessage, logLevel);
+        formattedLogLevel = this.colorize(formattedLogLevel, logLevel);
+        return `${pidMessage}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}\n`;
+    }
+    stringifyMessage(message, logLevel) {
+        // If the message is a function, call it and re-resolve its value.
+        return (0, shared_helper_1.isFunction)(message)
+            ? this.stringifyMessage(message(), logLevel)
+            : (0, shared_helper_1.isPlainObject)(message) || Array.isArray(message)
+                ? `${this.colorize("Object:", logLevel)}\n${JSON.stringify(message, (key, value) => (typeof value === "bigint" ? value.toString() : value), 2)}\n`
+                : this.colorize(message, logLevel);
+    }
+    colorize(message, logLevel) {
+        const color = this.getColorByLogLevel(logLevel);
+        return color(message);
+    }
+    printStackTrace(stack) {
+        if (!stack)
+            return;
+        process.stderr.write(`${stack}\n`);
+    }
+    updateAndGetTimestampDiff() {
+        const includeTimestamp = ConsoleLogger_1.lastTimestampAt && this.options?.timestamp;
+        const ts = typeof ConsoleLogger_1.lastTimestampAt !== "undefined" ? ConsoleLogger_1.lastTimestampAt : 0;
+        const result = includeTimestamp ? this.formatTimestampDiff(Date.now() - ts) : "";
+        ConsoleLogger_1.lastTimestampAt = Date.now();
+        return result;
+    }
+    formatTimestampDiff(timestampDiff) {
+        return (0, color_helper_1.yellow)(` +${timestampDiff}ms`);
+    }
+    getContextAndMessagesToPrint(args) {
+        if (args?.length <= 1)
+            return { messages: args, context: this.context };
+        const lastElement = args[args.length - 1];
+        const isContext = (0, shared_helper_1.isString)(lastElement);
+        if (!isContext)
+            return { messages: args, context: this.context };
+        return {
+            context: lastElement,
+            messages: args.slice(0, args.length - 1),
+        };
+    }
+    getContextAndStackAndMessagesToPrint(args) {
+        if (args.length === 2) {
+            return this.isStackFormat(args[1])
+                ? {
+                    messages: [args[0]],
+                    stack: args[1],
+                    context: this.context,
+                }
+                : {
+                    messages: [args[0]],
+                    context: args[1],
+                };
+        }
+        const { messages, context } = this.getContextAndMessagesToPrint(args);
+        if (messages?.length <= 1)
+            return { messages, context };
+        const lastElement = messages[messages.length - 1];
+        const isStack = (0, shared_helper_1.isString)(lastElement);
+        // https://github.com/nestjs/nest/issues/11074#issuecomment-1421680060
+        if (!isStack && !(0, shared_helper_1.isUndefined)(lastElement))
+            return { messages, context };
+        return {
+            stack: lastElement,
+            messages: messages.slice(0, messages.length - 1),
+            context,
+        };
+    }
+    isStackFormat(stack) {
+        if (!(0, shared_helper_1.isString)(stack))
+            return false;
+        return /^(.)+\n\s+at .+:\d+:\d+$/.test(stack);
+    }
+    getColorByLogLevel(level) {
+        switch (level) {
+            case "debug":
+                return color_helper_1.colors.magentaBright;
+            case "warn":
+                return color_helper_1.colors.yellow;
+            case "error":
+                return color_helper_1.colors.red;
+            case "verbose":
+                return color_helper_1.colors.cyanBright;
+            case "fatal":
+                return color_helper_1.colors.bold;
+            default:
+                return color_helper_1.colors.green;
+        }
+    }
+};
+exports.ConsoleLogger = ConsoleLogger;
+exports.ConsoleLogger = ConsoleLogger = ConsoleLogger_1 = __decorate([
+    (0, injectable_decorator_1.Injectable)(),
+    __param(0, (0, optional_decorator_1.Optional)()),
+    __param(1, (0, optional_decorator_1.Optional)()),
+    __metadata("design:paramtypes", [String, Object])
+], ConsoleLogger);

package/services/index.d.ts

@@ -0,0 +1 @@
+export * from "./reflector.service";

package/services/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./reflector.service"), exports);

package/services/logger.service.d.ts

@@ -0,0 +1,157 @@
+/**
+ * @publicApi
+ */
+export type LogLevel = "log" | "error" | "warn" | "debug" | "verbose" | "fatal";
+/**
+ * Checks if target level is enabled.
+ * @param targetLevel target level
+ * @param logLevels array of enabled log levels
+ */
+export declare function isLogLevelEnabled(targetLevel: LogLevel, logLevels: LogLevel[] | undefined): boolean;
+/**
+ * @publicApi
+ */
+export interface LoggerService {
+    /**
+     * Write a 'log' level log.
+     */
+    log(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write an 'error' level log.
+     */
+    error(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'warn' level log.
+     */
+    warn(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'debug' level log.
+     */
+    debug?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'verbose' level log.
+     */
+    verbose?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'fatal' level log.
+     */
+    fatal?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Set log levels.
+     * @param levels log levels
+     */
+    setLogLevels?(levels: LogLevel[]): any;
+}
+interface LogBufferRecord {
+    /**
+     * Method to execute.
+     */
+    methodRef: Function;
+    /**
+     * Arguments to pass to the method.
+     */
+    arguments: unknown[];
+}
+/**
+ * @publicApi
+ */
+export declare class Logger implements LoggerService {
+    protected context?: string | undefined;
+    protected options: {
+        timestamp?: boolean;
+    };
+    protected static logBuffer: LogBufferRecord[];
+    protected static staticInstanceRef: LoggerService;
+    protected static logLevels?: LogLevel[];
+    private static isBufferAttached;
+    protected localInstanceRef?: LoggerService;
+    private static WrapBuffer;
+    constructor();
+    constructor(context: string);
+    constructor(context: string, options?: {
+        timestamp?: boolean;
+    });
+    get localInstance(): LoggerService;
+    /**
+     * Write an 'error' level log.
+     */
+    error(message: any, stack?: string, context?: string): void;
+    error(message: any, ...optionalParams: [...any, string?, string?]): void;
+    /**
+     * Write a 'log' level log.
+     */
+    log(message: any, context?: string): void;
+    log(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'warn' level log.
+     */
+    warn(message: any, context?: string): void;
+    warn(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'debug' level log.
+     */
+    debug(message: any, context?: string): void;
+    debug(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'verbose' level log.
+     */
+    verbose(message: any, context?: string): void;
+    verbose(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'fatal' level log.
+     */
+    fatal(message: any, context?: string): void;
+    fatal(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write an 'error' level log.
+     */
+    static error(message: any, stackOrContext?: string): void;
+    static error(message: any, context?: string): void;
+    static error(message: any, stack?: string, context?: string): void;
+    static error(message: any, ...optionalParams: [...any, string?, string?]): void;
+    /**
+     * Write a 'log' level log.
+     */
+    static log(message: any, context?: string): void;
+    static log(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'warn' level log.
+     */
+    static warn(message: any, context?: string): void;
+    static warn(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'debug' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    static debug(message: any, context?: string): void;
+    static debug(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'verbose' level log.
+     */
+    static verbose(message: any, context?: string): void;
+    static verbose(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'fatal' level log.
+     */
+    static fatal(message: any, context?: string): void;
+    static fatal(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Print buffered logs and detach buffer.
+     */
+    static flush(): void;
+    /**
+     * Attach buffer.
+     * Turns on initialization logs buffering.
+     */
+    static attachBuffer(): void;
+    /**
+     * Detach buffer.
+     * Turns off initialization logs buffering.
+     */
+    static detachBuffer(): void;
+    static getTimestamp(): string;
+    static overrideLogger(logger: LoggerService | LogLevel[] | boolean): any;
+    static isLevelEnabled(level: LogLevel): boolean;
+    private registerLocalInstanceRef;
+}
+export {};