@warlock.js/logger 1.0.0

package/cjs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;AAEvE,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAElE,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,GAAG,CACD,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,GAAG,EACZ,KAAK,EAAE,QAAQ,GACd,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB"}

package/cjs/utils.d.ts

@@ -0,0 +1,6 @@
+export declare function captureAnyUnhandledRejection(): void;
+/**
+ * Clear message from any terminal codes
+ */
+export declare function clearMessage(message: any): any;
+//# sourceMappingURL=utils.d.ts.map

package/cjs/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,wBAAgB,4BAA4B,SAY3C;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,GAAG,OAKxC"}

package/cjs/utils.js

@@ -0,0 +1,21 @@
+'use strict';var logger=require('./logger.js');function captureAnyUnhandledRejection() {
+    process.on("unhandledRejection", (reason, promise) => {
+        logger.log.error("app", reason, promise);
+        console.log(promise);
+        // console.trace();
+    });
+    process.on("uncaughtException", (error) => {
+        logger.log.error("app", "error", error);
+        // console.trace();
+        console.log(error);
+    });
+}
+/**
+ * Clear message from any terminal codes
+ */
+function clearMessage(message) {
+    if (typeof message !== "string")
+        return message;
+    // eslint-disable-next-line no-control-regex
+    return message.replace(/\u001b[^m]*?m/g, "");
+}exports.captureAnyUnhandledRejection=captureAnyUnhandledRejection;exports.clearMessage=clearMessage;//# sourceMappingURL=utils.js.map

package/cjs/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../src/utils.ts"],"sourcesContent":[null],"names":["log"],"mappings":"wDAEgB,4BAA4B,GAAA;IAC1C,OAAO,CAAC,EAAE,CAAC,oBAAoB,EAAE,CAAC,MAAc,EAAE,OAAO,KAAI;QAC3DA,UAAG,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AAClC,QAAA,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;;AAEvB,KAAC,CAAC,CAAC;IAEH,OAAO,CAAC,EAAE,CAAC,mBAAmB,EAAE,CAAC,KAAK,KAAI;QACxCA,UAAG,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;;AAEjC,QAAA,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACrB,KAAC,CAAC,CAAC;AACL,CAAC;AAED;;AAEG;AACG,SAAU,YAAY,CAAC,OAAY,EAAA;IACvC,IAAI,OAAO,OAAO,KAAK,QAAQ;AAAE,QAAA,OAAO,OAAO,CAAC;;IAGhD,OAAO,OAAO,CAAC,OAAO,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC;AAC/C"}

package/esm/LogChannel.d.ts

@@ -0,0 +1,20 @@
+import { LogContract, LogLevel } from "./types";
+export declare abstract class LogChannel implements LogContract {
+    /**
+     * Channel name
+     */
+    name: string;
+    /**
+     * Channel description
+     */
+    description?: string;
+    /**
+     * Determine if channel is logging in terminal
+     */
+    terminal: boolean;
+    /**
+     * Log the given message
+     */
+    abstract log(module: string, action: string, message: any, level: LogLevel): void | Promise<void>;
+}
+//# sourceMappingURL=LogChannel.d.ts.map

package/esm/LogChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogChannel.d.ts","sourceRoot":"","sources":["../src/LogChannel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEhD,8BAAsB,UAAW,YAAW,WAAW;IACrD;;OAEG;IACI,IAAI,EAAG,MAAM,CAAC;IAErB;;OAEG;IACI,WAAW,CAAC,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACI,QAAQ,UAAS;IAExB;;OAEG;aACa,GAAG,CACjB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,GAAG,EACZ,KAAK,EAAE,QAAQ,GACd,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CACxB"}

package/esm/LogChannel.js

@@ -0,0 +1,14 @@
+class LogChannel {
+    /**
+     * Channel name
+     */
+    name;
+    /**
+     * Channel description
+     */
+    description;
+    /**
+     * Determine if channel is logging in terminal
+     */
+    terminal = false;
+}export{LogChannel};//# sourceMappingURL=LogChannel.js.map

package/esm/LogChannel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogChannel.js","sources":["../src/LogChannel.ts"],"sourcesContent":[null],"names":[],"mappings":"MAEsB,UAAU,CAAA;AAC9B;;AAEG;AACI,IAAA,IAAI,CAAU;AAErB;;AAEG;AACI,IAAA,WAAW,CAAU;AAE5B;;AAEG;IACI,QAAQ,GAAG,KAAK,CAAC;AAWzB"}

package/esm/channels/console-log.d.ts

@@ -0,0 +1,17 @@
+import { LogChannel } from "../LogChannel";
+import { LogLevel } from "../types";
+export declare class ConsoleLog extends LogChannel {
+    /**
+     * {@inheritdoc}
+     */
+    name: string;
+    /**
+     * Determine if channel is logging in terminal
+     */
+    terminal: boolean;
+    /**
+     * {@inheritdoc}
+     */
+    log(module: string, action: string, message: any, level: LogLevel): void;
+}
+//# sourceMappingURL=console-log.d.ts.map

package/esm/channels/console-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-log.d.ts","sourceRoot":"","sources":["../../src/channels/console-log.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,qBAAa,UAAW,SAAQ,UAAU;IACxC;;OAEG;IACI,IAAI,SAAa;IAExB;;OAEG;IACI,QAAQ,UAAQ;IAEvB;;OAEG;IACI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,QAAQ;CAsEzE"}

package/esm/channels/console-log.js

@@ -0,0 +1,44 @@
+import {colors}from'@mongez/copper';import {LogChannel}from'../LogChannel.js';class ConsoleLog extends LogChannel {
+    /**
+     * {@inheritdoc}
+     */
+    name = "console";
+    /**
+     * Determine if channel is logging in terminal
+     */
+    terminal = true;
+    /**
+     * {@inheritdoc}
+     */
+    log(module, action, message, level) {
+        // display date and time with milliseconds
+        const date = new Date().toISOString(); // i.e 2021-01-01T00:00:00.000Z
+        switch (level) {
+            case "debug":
+                // add a debug icon
+                console.log(colors.magentaBright("⚙"), colors.yellow(`(${date})`), colors.cyan(`[${module}]`), colors.magenta(`[${action}]`), colors.magentaBright(message));
+                break;
+            case "info":
+                // add an info icon
+                console.log(colors.blueBright("ℹ"), colors.yellow(`(${date})`), colors.cyan(`[${module}]`), colors.magenta(`[${action}]`), colors.blueBright(message));
+                break;
+            case "warn":
+                // add a warning icon
+                console.log(colors.yellow("⚠"), colors.green(`(${date})`), colors.cyan(`[${module}]`), colors.magenta(`[${action}]`), colors.yellowBright(message));
+                break;
+            case "error":
+                // add an error icon
+                console.log(colors.red("✗"), colors.yellow(`(${date})`), colors.cyan(`[${module}]`), colors.magenta(`[${action}]`), colors.redBright(message));
+                break;
+            case "success":
+                // add a success icon
+                console.log(colors.green("✓"), colors.yellow(`(${date})`), colors.cyan(`[${module}]`), colors.magenta(`[${action}]`), colors.greenBright(message));
+                break;
+            default:
+                console.log("[log]", colors.yellow(`(${date})`), colors.cyan(`[${module}]`), colors.magenta(`[${action}]`), message);
+        }
+        if (typeof message === "object") {
+            console.log(message);
+        }
+    }
+}export{ConsoleLog};//# sourceMappingURL=console-log.js.map

package/esm/channels/console-log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-log.js","sources":["../../src/channels/console-log.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/esm/channels/file-log.d.ts

@@ -0,0 +1,202 @@
+import { LogChannel } from "../LogChannel";
+import { LogContract, LogLevel } from "../types";
+export type FilteringOptions = {
+    level: LogLevel;
+    module: string;
+    action: string;
+};
+export type FileLogConfig = {
+    storagePath?: string;
+    /**
+     * File name, without extension
+     */
+    name?: string;
+    /**
+     * chunk mode
+     * If set to `single`, the logs will be created in a single file, unless the rotate is set to true
+     * If set to `daily`, the logs will be created in a daily file, unless the rotate is set to true
+     * If set to `hourly`, the logs will be created in an hourly file, unless the rotate is set to true
+     * @default single
+     */
+    chunk?: "single" | "daily" | "hourly";
+    /**
+     * Whether to rotate the file
+     *
+     * @default true
+     */
+    rotate?: boolean;
+    /**
+     * File Extension
+     *
+     * @default log
+     */
+    extension?: string;
+    /**
+     * If rotate is set, the rotate name will be added to the file name suffixed with `-`
+     *
+     * @default DD-MM-YYYY
+     */
+    rotateFileName?: string;
+    /**
+     * Max file size before rotating the file
+     *
+     * @default 10MB
+     */
+    maxFileSize?: number;
+    /**
+     * Set the max messages that needs to be added before writing to the file
+     *
+     * @default 100
+     */
+    maxMessagesToWrite?: number;
+    /**
+     * Group logs by
+     * Please note that the order matters here
+     * For example, if you set `groupBy: ['level', 'module']`, the logs will be added in level name first, then by module
+     *
+     * @default none
+     */
+    groupBy?: ("level" | "module" | "action")[];
+    /**
+     * Define what levels should be logged
+     *
+     * @default all
+     */
+    levels?: LogLevel[];
+    /**
+     * Filter what logs should be logged
+     *
+     * @default all
+     */
+    filter?: (options: FilteringOptions) => boolean;
+    /**
+     * Date and time format
+     */
+    dateFormat?: {
+        date?: string;
+        time?: string;
+    };
+};
+export type LogMessage = {
+    content: string;
+    level: LogLevel;
+    date: string;
+    module: string;
+    action: string;
+    stack: string;
+};
+export declare class FileLog extends LogChannel implements LogContract {
+    /**
+     * {@inheritdoc}
+     */
+    name: string;
+    /**
+     * Messages buffer
+     */
+    protected messages: LogMessage[];
+    /**
+     * Grouped messages
+     */
+    protected groupedMessages: Record<string, LogMessage[]>;
+    /**
+     * Default channel configurations
+     */
+    protected defaultConfigurations: FileLogConfig;
+    /**
+     * Last write time
+     */
+    protected lastWriteTime: number;
+    /**
+     * Channel configurations
+     */
+    protected channelConfigurations: FileLogConfig;
+    /**
+     * A flag to determine if the file is being written
+     */
+    protected isWriting: boolean;
+    /**
+     * Get config value
+     */
+    protected config<K extends keyof FileLogConfig>(key: K): FileLogConfig[K];
+    /**
+     * Constructor
+     */
+    constructor(configurations?: FileLogConfig);
+    /**
+     * Check file size for file rotation
+     */
+    protected checkAndRotateFile(filePath?: string): Promise<void>;
+    /**
+     * Rotate log file
+     */
+    protected rotateLogFile(): Promise<void>;
+    /**
+     * Flush messages
+     */
+    protected initMessageFlush(): void;
+    /**
+     * Get file path
+     */
+    get filePath(): string;
+    /**
+     * Get max messages
+     */
+    protected get maxMessagesToWrite(): number;
+    /**
+     * Get file name
+     */
+    get fileName(): string;
+    /**
+     * Get file extension
+     */
+    get extension(): string;
+    /**
+     * Get content
+     */
+    protected get content(): string;
+    /**
+     * Get storage path
+     */
+    get storagePath(): string;
+    /**
+     * {@inheritdoc}
+     */
+    protected init(): Promise<void>;
+    /**
+     * Set configurations
+     */
+    configurations(configurations: FileLogConfig): this;
+    /**
+     * {@inheritdoc}
+     */
+    log(module: string, action: string, message: any, level: LogLevel): Promise<void>;
+    /**
+     * Check if messages should be written
+     */
+    protected checkIfMessagesShouldBeWritten(): Promise<void>;
+    /**
+     * Should be called after messages are saved
+     */
+    protected onSave(): void;
+    /**
+     * Check if messages should be grouped
+     */
+    protected get messagedShouldBeGrouped(): boolean;
+    /**
+     * Write messages to the file
+     */
+    protected writeMessagesToFile(): Promise<void>;
+    /**
+     * Write grouped messages to the file
+     */
+    protected writeGroupedMessagesToFile(): Promise<void>;
+    /**
+     * Prepare grouped messages
+     */
+    protected prepareGroupedMessages(): void;
+    /**
+     * Start writing to the file
+     */
+    protected write(filePath: string, content: string): Promise<unknown>;
+}
+//# sourceMappingURL=file-log.d.ts.map

package/esm/channels/file-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-log.d.ts","sourceRoot":"","sources":["../../src/channels/file-log.ts"],"names":[],"mappings":"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"}

package/esm/channels/file-log.js

@@ -0,0 +1,315 @@
+import {ensureDirectoryAsync}from'@mongez/fs';import dayjs from'dayjs';import fs from'fs';import {EOL}from'os';import {LogChannel}from'../LogChannel.js';import path from'path';class FileLog extends LogChannel {
+    /**
+     * {@inheritdoc}
+     */
+    name = "file";
+    /**
+     * Messages buffer
+     */
+    messages = [];
+    /**
+     * Grouped messages
+     */
+    groupedMessages = {};
+    /**
+     * Default channel configurations
+     */
+    defaultConfigurations = {
+        storagePath: process.cwd() + "/storage/logs",
+        rotate: true,
+        name: "app",
+        extension: "log",
+        chunk: "single",
+        maxMessagesToWrite: 100,
+        // maxFileSize: 10 * 1024 * 1024, // 10MB
+        maxFileSize: 10,
+        get rotateFileName() {
+            return dayjs().format("DD-MM-YYYY");
+        },
+        dateFormat: {
+            date: "DD-MM-YYYY",
+            time: "HH:mm:ss",
+        },
+    };
+    /**
+     * Last write time
+     */
+    lastWriteTime = Date.now();
+    /**
+     * Channel configurations
+     */
+    channelConfigurations = {};
+    /**
+     * A flag to determine if the file is being written
+     */
+    isWriting = false;
+    /**
+     * Get config value
+     */
+    config(key) {
+        return this.channelConfigurations[key] ?? this.defaultConfigurations[key];
+    }
+    /**
+     * Constructor
+     */
+    constructor(configurations) {
+        super();
+        if (configurations) {
+            this.configurations(configurations);
+        }
+        this.init();
+        this.initMessageFlush();
+    }
+    /**
+     * Check file size for file rotation
+     */
+    async checkAndRotateFile(filePath = this.filePath) {
+        if (!this.config("rotate"))
+            return;
+        try {
+            const stats = await fs.promises.stat(filePath);
+            if (stats.size >= this.config("maxFileSize")) {
+                await this.rotateLogFile();
+            }
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                // File doesn't exist, this can be normal if it's a new file
+                console.log("Log file does not exist, will be created on first write.");
+            }
+            else {
+                console.error("Error checking log file:", error);
+            }
+        }
+    }
+    /**
+     * Rotate log file
+     */
+    async rotateLogFile() {
+        let fileName = `${this.fileName}-${this.config("rotateFileName")}-${Date.now()}`;
+        const extension = this.extension;
+        const rotatedFilePath = path.join(this.storagePath, `${fileName}.${extension}`);
+        await fs.promises.rename(this.filePath, rotatedFilePath).catch((error) => {
+            console.error("Error rotating file:", error);
+        });
+    }
+    /**
+     * Flush messages
+     */
+    initMessageFlush() {
+        setInterval(() => {
+            if (this.messages.length > 0 &&
+                (this.messages.length >= this.maxMessagesToWrite ||
+                    Date.now() - this.lastWriteTime > 5000)) {
+                this.writeMessagesToFile();
+            }
+        }, 5000); // Periodic check
+    }
+    /**
+     * Get file path
+     */
+    get filePath() {
+        let fileName = this.fileName;
+        const extension = this.extension;
+        return path.join(this.storagePath, `${fileName}.${extension}`);
+    }
+    /**
+     * Get max messages
+     */
+    get maxMessagesToWrite() {
+        return this.config("maxMessagesToWrite");
+    }
+    /**
+     * Get file name
+     */
+    get fileName() {
+        const debugLevel = this.config("chunk");
+        switch (debugLevel) {
+            case "single":
+            default:
+                return this.config("name");
+            case "daily":
+                return dayjs().format("DD-MM-YYYY");
+            case "hourly":
+                return dayjs().format("DD-MM-YYYY-HH");
+        }
+    }
+    /**
+     * Get file extension
+     */
+    get extension() {
+        return this.config("extension");
+    }
+    /**
+     * Get content
+     */
+    get content() {
+        return this.messages.map((message) => message.content).join(EOL) + EOL;
+    }
+    /**
+     * Get storage path
+     */
+    get storagePath() {
+        return this.config("storagePath");
+    }
+    /**
+     * {@inheritdoc}
+     */
+    async init() {
+        const logsDirectory = this.storagePath;
+        await ensureDirectoryAsync(logsDirectory);
+    }
+    /**
+     * Set configurations
+     */
+    configurations(configurations) {
+        this.channelConfigurations = {
+            ...this.channelConfigurations,
+            ...configurations,
+            dateFormat: {
+                ...this.channelConfigurations.dateFormat,
+                ...configurations.dateFormat,
+            },
+        };
+        return this;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    async log(module, action, message, level) {
+        // check for debug mode
+        const allowedLevels = this.config("levels");
+        if (allowedLevels && !allowedLevels.includes(level))
+            return;
+        const filter = this.config("filter");
+        if (filter) {
+            const shouldBeLogged = filter({ level, module, action });
+            if (!shouldBeLogged)
+                return;
+        }
+        const date = dayjs().format((this.channelConfigurations.dateFormat.date || "DD-MM-YYY") +
+            " " +
+            (this.channelConfigurations.dateFormat.time || "HH:mm:ss"));
+        let content = `[${date}] [${level}] [${module}][${action}]: `;
+        let stack = "";
+        // check if message is an instance of Error
+        if (message instanceof Error) {
+            // in that case we need to store the error message and stack trace
+            content += message.message + EOL;
+            content += `[trace]` + EOL;
+            content += message.stack;
+            stack = message.stack ?? "";
+        }
+        else {
+            content += message;
+        }
+        this.messages.push({
+            content,
+            level,
+            date,
+            module,
+            action,
+            stack,
+        });
+        await this.checkIfMessagesShouldBeWritten(); // Immediate check on buffer size
+    }
+    /**
+     * Check if messages should be written
+     */
+    async checkIfMessagesShouldBeWritten() {
+        if (this.messages.length >= this.maxMessagesToWrite ||
+            Date.now() - this.lastWriteTime > 5000) {
+            await this.writeMessagesToFile();
+        }
+    }
+    /**
+     * Should be called after messages are saved
+     */
+    onSave() {
+        this.messages = [];
+        this.groupedMessages = {};
+        this.isWriting = false;
+        this.lastWriteTime = Date.now();
+    }
+    /**
+     * Check if messages should be grouped
+     */
+    get messagedShouldBeGrouped() {
+        return Number(this.config("groupBy")?.length) > 0;
+    }
+    /**
+     * Write messages to the file
+     */
+    async writeMessagesToFile() {
+        if (this.messages.length === 0 || this.isWriting)
+            return;
+        this.isWriting = true;
+        if (this.messagedShouldBeGrouped) {
+            return await this.writeGroupedMessagesToFile();
+        }
+        await this.checkAndRotateFile(); // Ensure we check file size before writing
+        try {
+            await this.write(this.filePath, this.content);
+            this.onSave();
+        }
+        catch (error) {
+            console.error("Failed to write log:", error);
+            // Implement fallback logic here
+            this.isWriting = false;
+        }
+    }
+    /**
+     * Write grouped messages to the file
+     */
+    async writeGroupedMessagesToFile() {
+        // first step, is to group the messages
+        this.prepareGroupedMessages();
+        // now each key in the grouped messages, represents the directory path that should extend the storage path
+        for (const key in this.groupedMessages) {
+            const directoryPath = path.join(this.storagePath, key);
+            await ensureDirectoryAsync(directoryPath);
+            const filePath = path.join(directoryPath, `${this.fileName}.${this.extension}`);
+            await this.checkAndRotateFile(filePath); // Ensure we check file size before writing
+            const content = this.groupedMessages[key].map((message) => message.content).join(EOL) +
+                EOL;
+            console.log("content", content);
+            try {
+                await this.write(filePath, content);
+            }
+            catch (error) {
+                console.error("Failed to write log:", error);
+            }
+        }
+        this.onSave();
+        this.isWriting = false;
+    }
+    /**
+     * Prepare grouped messages
+     */
+    prepareGroupedMessages() {
+        this.messages.forEach((message) => {
+            const key = this.config("groupBy")
+                .map((groupKey) => encodeURIComponent(message[groupKey]))
+                .join("/");
+            this.groupedMessages[key] = this.groupedMessages[key] || [];
+            this.groupedMessages[key].push(message);
+        });
+    }
+    /**
+     * Start writing to the file
+     */
+    async write(filePath, content) {
+        return new Promise((resolve, reject) => {
+            const writer = fs.createWriteStream(filePath, { flags: "a" });
+            writer.write(content, (error) => {
+                writer.end();
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(true);
+                }
+            });
+        });
+    }
+}export{FileLog};//# sourceMappingURL=file-log.js.map