@basalt.lab/basalt-logger 1.10.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Basalt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# 📦 Basalt-logger
+
+## 📌 Table of contents
+
+- [📦 Basalt-logger](#-basalt-logger)
+    - [📌 Table of contents](#-table-of-contents)
+    - [📝 Description](#-description)
+    - [🌟 Documentation](#-documentation)
+    - [🔧 Installation](#-installation)
+    - [⚖️ License](#-license)
+    - [📧 Contact](#-contact)
+
+## 📝 Description
+
+`Basalt-logger` is a package that allows you to log events in your application in a simple and elegant way.
+`Basalt-logger` is non-blocking and allows you to have multiple logging strategies. This means you can create your own logging strategies and choose to log in all strategies or only in certain ones.
+
+## 🌟 Documentation
+
+- [Documentation](https://basalt-lab.github.io/basalt-doc/index.html).
+- [References](https://basalt-lab.github.io/basalt-logger/index.html).
+
+## 🔧 Installation
+
+NPM:
+```bash
+npm i @basalt-lab/basalt-logger
+```
+
+PNPM:
+```bash
+pnpm i @basalt-lab/basalt-logger
+```
+
+## ⚖️ License
+
+Distributed under the MIT License. See LICENSE for more information.
+
+## 📧 Contact
+
+Mail - [basalt-lab@proton.me](basalt-lab@proton.me)
+
+[Project link](https://github.com/Basalt-Lab/basalt-logger)

package/build/chunk-kadx22tz.js

@@ -0,0 +1,2 @@
+import{randomUUID as k}from"crypto";class q extends Error{_uuidError=k();_date=new Date;_code;_detail;constructor(j){super();if(this._code=j.code??500,this.message=j.messageKey,this._detail=j.detail,this.name="BasaltError",Error.captureStackTrace)Error.captureStackTrace(this,this.constructor)}get uuidError(){return this._uuidError}get date(){return this._date}get code(){return this._code}get detail(){return this._detail}}var x={STRATEGY_ALREADY_ADDED:"error.basalt-logger.strategy_already_added",STRATEGY_NOT_FOUND:"error.basalt-logger.strategy_not_found",NO_STRATEGY_ADDED:"error.basalt-logger.no_strategy_added"};
+export{q as b,x as c};

package/build/chunk-mcf4zz53.js

@@ -0,0 +1,2 @@
+var j;((h)=>{h.ERROR="ERROR";h.WARN="WARN";h.INFO="INFO";h.DEBUG="DEBUG";h.LOG="LOG"})(j||={});
+export{j as f};

package/build/chunk-wp46zt40.js

@@ -0,0 +1,2 @@
+class J{_colorize;constructor(x=!1){this._colorize=x}log(x,G,A){let H=this._colorize?"\x1B[33m":"",E=this._colorize?"\x1B[0m":"",I=typeof A==="string"?A:JSON.stringify(A),q="";switch(x){case"ERROR":q=this._colorize?"\x1B[31m":"";break;case"WARN":q=this._colorize?"\x1B[33m":"";break;case"INFO":q=this._colorize?"\x1B[36m":"";break;case"DEBUG":q=this._colorize?"\x1B[35m":"";break;default:q=this._colorize?"\x1B[37m":"";break}let B=`${`[${H}${G.toISOString().replace(/T/," ").replace(/\..+/,"")}${E}]`} ${q}${x}${E} : ${I}`;switch(x){case"ERROR":console.error(B);break;case"WARN":console.warn(B);break;case"INFO":console.info(B);break;case"DEBUG":console.debug(B);break;case"LOG":console.log(B);break;default:break}}}import{appendFile as K}from"fs";class M{_path;constructor(x){this._path=x}log(x,G,A){let H=`[${G.toISOString().replace(/T/," ").replace(/\..+/,"")}]`,E=typeof A==="string"?A:JSON.stringify(A),I=`${H} ${x} : ${E}`;K(this._path,`${I}
+`,(q)=>{if(q)throw q})}}export{J as d,M as e};

package/build/chunk-xymy9zxw.js

@@ -0,0 +1,2 @@
+import{b as z,c as A}from"./chunk-kadx22tz.js";import{Transform as F}from"stream";class G{_strategies=new Map;_logStream;_pendingLogs=[];_maxPendingLogs=1e4;_writing=!1;constructor(){this._logStream=new F({objectMode:!0,transform:(q,w,x)=>{this.executeStrategies(q.level,new Date(q.date),q.object,q.strategiesNames),x()}})}addStrategy(q,w){if(this._strategies.has(q))throw new z({messageKey:A.STRATEGY_ALREADY_ADDED,detail:{strategyName:q}});this._strategies.set(q,w)}removeStrategy(q){if(!this._strategies.has(q))throw new z({messageKey:A.STRATEGY_NOT_FOUND,detail:{strategyName:q}});this._strategies.delete(q)}clearStrategies(){this._strategies.clear()}error(q,w){this.out("ERROR",q,w)}warn(q,w){this.out("WARN",q,w)}info(q,w){this.out("INFO",q,w)}debug(q,w){this.out("DEBUG",q,w)}log(q,w){this.out("LOG",q,w)}executeStrategies(q,w,x,C){for(let D of C)this._strategies.get(D)?.log(q,w,x)}out(q,w,x=[...this._strategies.keys()]){if(this._strategies.size===0)throw new z({messageKey:A.NO_STRATEGY_ADDED});if(this._pendingLogs.length>=this._maxPendingLogs)return;let C={date:new Date().toISOString(),level:q,object:w,strategiesNames:x};if(this._pendingLogs.push(C),!this._writing)this._writing=!0,setImmediate(this.writeLog.bind(this))}writeLog(){let q=!0;while(q&&this._pendingLogs.length>0){let w=this._pendingLogs.shift();q=this._logStream.write(w)}if(!q)this._logStream.once("drain",this.writeLog.bind(this));else this._writing=!1}}
+export{G as a};

package/build/common/error/basalt.error.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Represents the options for the Basalt error.
+ */
+export interface BasaltErrorOptions {
+    /**
+     * The error key.
+     */
+    messageKey: string;
+    /**
+     * The status code.
+     */
+    code?: number;
+    /**
+     * The error detail.
+     */
+    detail?: unknown;
+}
+/**
+ * BasaltError is a class that represents an error entity with a unique identifier.
+ */
+export declare class BasaltError extends Error {
+    /**
+     * The unique identifier of the error.
+     * This identifier is used to track the error in the logs.
+     */
+    private readonly _uuidError;
+    /**
+     * The date when the error was created.
+     */
+    private readonly _date;
+    /**
+     * The error code.
+     */
+    private readonly _code;
+    /**
+     * The error detail.
+     */
+    private readonly _detail;
+    /**
+     * Creates a new instance of the ErrorEntity class.
+     *
+     * @param basaltErrorOptions - The options to create the error entity. ({@link BasaltErrorOptions})
+     */
+    constructor(basaltErrorOptions: Readonly<BasaltErrorOptions>);
+    /**
+     * Gets the unique identifier of the error.
+     *
+     * @returns The unique identifier of the error.
+     */
+    get uuidError(): string;
+    /**
+     * Gets the date when the error was created.
+     *
+     * @returns The date when the error was created.
+     */
+    get date(): Date;
+    /**
+     * Gets the error code.
+     *
+     * @returns The error code.
+     */
+    get code(): number;
+    /**
+     * Gets the error detail.
+     *
+     * @returns The error detail.
+     */
+    get detail(): unknown;
+}

package/build/common/error/index.d.ts

@@ -0,0 +1,2 @@
+export * from './basalt.error.ts';
+export * from './keys.error.ts';

package/build/common/error/index.js

@@ -0,0 +1 @@
+import"../../chunk-x3cvtn7y.js";import{b as a,c as b}from"../../chunk-kadx22tz.js";export{b as ErrorKeys,a as BasaltError};

package/build/common/error/keys.error.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Error keys for the Basalt logger
+ */
+export declare const ErrorKeys: {
+    /**
+     * Interpolation :
+     * - strategyName : The name of the strategy.
+     */
+    STRATEGY_ALREADY_ADDED: string;
+    /**
+     * Interpolation :
+     * - strategyName : The name of the strategy
+     */
+    STRATEGY_NOT_FOUND: string;
+    NO_STRATEGY_ADDED: string;
+};

package/build/common/type/data/index.d.ts

@@ -0,0 +1 @@
+export type * from './loggerStrategy.data.ts';

package/build/common/type/data/loggerStrategy.data.d.ts

@@ -0,0 +1,11 @@
+import type { LogLevels } from '../../../common/type/enum/logLevels.enum.ts';
+export interface LoggerStrategy {
+    /**
+     * Logs a message with the strategy's implementation.
+     *
+     * @param level - The log level at which the message should be logged. ({@link LogLevels})
+     * @param date - The date at which the message was logged.
+     * @param object - The object to log.
+     */
+    log(level: LogLevels, date: Date, object: unknown): void;
+}

package/build/common/type/enum/index.d.ts

@@ -0,0 +1 @@
+export * from './logLevels.enum.ts';

package/build/common/type/enum/index.js

@@ -0,0 +1 @@
+import"../../../chunk-amcnfafr.js";import{f as a}from"../../../chunk-mcf4zz53.js";export{a as LogLevels};

package/build/common/type/enum/logLevels.enum.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Enum for log levels used in BasaltLogger.
+ * This enum defines different levels of logging severity.
+ */
+export declare enum LogLevels {
+    /**
+     * Log level for error messages, indicating critical issues that need attention.
+     */
+    ERROR = "ERROR",
+    /**
+     * Log level for warning messages, indicating potential issues or warnings.
+     */
+    WARN = "WARN",
+    /**
+     * Log level for informational messages, providing general information about application processes.
+     */
+    INFO = "INFO",
+    /**
+     * Log level for debug messages, useful for debugging and development purposes.
+     */
+    DEBUG = "DEBUG",
+    /**
+     * Log level for general log messages, suitable for recording standard operational events.
+     */
+    LOG = "LOG"
+}

package/build/domain/service/basaltLogger.service.d.ts

@@ -0,0 +1,109 @@
+import type { LoggerStrategy } from '../../common/type/data/loggerStrategy.data.ts';
+/**
+ * BasaltLogger provides a flexible logging system that allows multiple strategies for log output.
+ */
+export declare class BasaltLogger {
+    /**
+     * Stores the logging strategies mapped by their names. ({@link LoggerStrategy})
+     */
+    private readonly _strategies;
+    /**
+     * Transform stream to process log entries. ({@link Transform})
+     */
+    private readonly _logStream;
+    /**
+     * Stores the pending log entries. ({@link LogStreamObject})
+     */
+    private readonly _pendingLogs;
+    /**
+     * The maximum number of pending logs.
+     */
+    private readonly _maxPendingLogs;
+    /**
+     * Indicates if the logger is writing log entries
+     */
+    private _writing;
+    /**
+     * Initializes the BasaltLogger.
+     */
+    constructor();
+    /**
+     * Adds a logging strategy.
+     *
+     * @param name - The name of the strategy.
+     * @param strategy - The strategy to add. ({@link LoggerStrategy})
+     *
+     * @throws ({@link BasaltError}) - If the strategy is already added. ({@link ErrorKeys.STRATEGY_ALREADY_ADDED})
+     */
+    addStrategy(name: string, strategy: LoggerStrategy): void;
+    /**
+     * Removes a logging strategy by name.
+     *
+     * @param name - The name of the strategy.
+     *
+     * @throws ({@link BasaltError}) - If the strategy is not found. ({@link ErrorKeys.STRATEGY_NOT_FOUND})
+     */
+    removeStrategy(name: string): void;
+    /**
+     * Clears all logging strategies.
+     */
+    clearStrategies(): void;
+    /**
+     * Logs an error message.
+     *
+     * @param object - The object to log.
+     * @param strategiesNames - The names of the strategies to use. (default: all strategies)
+     */
+    error(object: unknown, strategiesNames?: string[]): void;
+    /**
+     * Logs a warn message.
+     *
+     * @param object - The object to log.
+     * @param strategiesNames - The names of the strategies to use. (default: all strategies)
+     */
+    warn(object: unknown, strategiesNames?: string[]): void;
+    /**
+     * Logs an info message.
+     *
+     * @param object - The object to log.
+     * @param strategiesNames - The names of the strategies to use. (default: all strategies)
+     */
+    info(object: unknown, strategiesNames?: string[]): void;
+    /**
+     * Logs a debug message.
+     *
+     * @param object - The object to log.
+     * @param strategiesNames - The names of the strategies to use. (default: all strategies)
+     */
+    debug(object: unknown, strategiesNames?: string[]): void;
+    /**
+     * Logs a log message.
+     *
+     * @param object - The object to log.
+     * @param strategiesNames - The names of the strategies to use. (default: all strategies)
+     */
+    log(object: unknown, strategiesNames?: string[]): void;
+    /**
+     * Executes the logging strategies.
+     *
+     * @param level - The log level. ({@link LogLevels})
+     * @param date - The date of the log entry.
+     * @param object - The object to log.
+     * @param strategiesNames - The names of the strategies to use.
+     */
+    private executeStrategies;
+    /**
+     * Outputs the log entry.
+     *
+     * @param level - The log level. ({@link LogLevels})
+     * @param object - The object to log.
+     * @param strategiesNames - The names of the strategies to use. (default: all strategies)
+     *
+     * @throws ({@link BasaltError}) - If no strategy is added. ({@link ErrorKeys.NO_STRATEGY_ADDED})
+     */
+    private out;
+    /**
+     * Writes the log entries.
+     */
+    private writeLog;
+}

package/build/domain/service/basaltLogger.service.js

@@ -0,0 +1 @@
+import{a}from"../../chunk-xymy9zxw.js";import"../../chunk-kadx22tz.js";import"../../chunk-mcf4zz53.js";export{a as BasaltLogger};

package/build/domain/service/strategy/consoleLogger.strategy.d.ts

@@ -0,0 +1,22 @@
+import type { LoggerStrategy } from '../../../common/type/data/loggerStrategy.data.ts';
+import { LogLevels } from '../../../common/type/enum/logLevels.enum.ts';
+/**
+ * ConsoleLoggerStrategy implements LoggerStrategy to provide logging functionality to the console. ({@link LoggerStrategy})
+ */
+export declare class ConsoleLoggerStrategy implements LoggerStrategy {
+    private readonly _colorize;
+    /**
+     * Initializes the ConsoleLoggerStrategy.
+     *
+     * @param colorize - Indicates if the output should be colorized.
+     */
+    constructor(colorize?: boolean);
+    /**
+     * Logs a message to the console with the specified log level.
+     *
+     * @param level - The log level at which the message should be logged. ({@link LogLevels})
+     * @param date - The date at which the message was logged.
+     * @param object - The object to log.
+     */
+    log(level: LogLevels, date: Date, object: unknown): void;
+}

package/build/domain/service/strategy/fileLogger.strategy.d.ts

@@ -0,0 +1,25 @@
+import type { LoggerStrategy } from '../../../common/type/data/loggerStrategy.data.ts';
+import type { LogLevels } from '../../../common/type/enum/logLevels.enum.ts';
+/**
+ * FileLoggerStrategy implements LoggerStrategy to provide logging functionality to the file system. ({@link LoggerStrategy})
+ */
+export declare class FileLoggerStrategy implements LoggerStrategy {
+    /**
+     * Path to the file to log to.
+     */
+    private readonly _path;
+    /**
+     * Constructor FileLoggerStrategy
+     *
+     * @param path - Path to the file to log to.
+     */
+    constructor(path: string);
+    /**
+     * Logs a message to the file system with the specified log level.
+     *
+     * @param level - The log level at which the message should be logged. {@link LogLevels}
+     * @param date - The date at which the message was logged.
+     * @param object - The object to log.
+     */
+    log(level: LogLevels, date: Date, object: unknown): void;
+}

package/build/domain/service/strategy/index.d.ts

@@ -0,0 +1,2 @@
+export * from './consoleLogger.strategy.ts';
+export * from './fileLogger.strategy.ts';

package/build/domain/service/strategy/index.js

@@ -0,0 +1 @@
+import{d as a,e as b}from"../../../chunk-wp46zt40.js";import"../../../chunk-mcf4zz53.js";export{b as FileLoggerStrategy,a as ConsoleLoggerStrategy};

package/build/index.d.ts

@@ -0,0 +1,5 @@
+export * from './common/error/index.ts';
+export type * from './common/type/data/index.ts';
+export * from './common/type/enum/index.ts';
+export * from './domain/service/basaltLogger.service.ts';
+export * from './domain/service/strategy/index.ts';

package/build/index.js

@@ -0,0 +1 @@
+import"./chunk-x3cvtn7y.js";import"./chunk-amcnfafr.js";import{a as u}from"./chunk-xymy9zxw.js";import{b as l,c as p}from"./chunk-kadx22tz.js";import{d as w,e as z}from"./chunk-wp46zt40.js";import{f as q}from"./chunk-mcf4zz53.js";export{q as LogLevels,z as FileLoggerStrategy,p as ErrorKeys,w as ConsoleLoggerStrategy,u as BasaltLogger,l as BasaltError};

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@basalt.lab/basalt-logger",
+  "version": "1.10.0",
+  "description": "Logger module for Basalt Framework",
+  "type": "module",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "import": "./build/index.js",
+      "require": "./build/index.js"
+    },
+    "./error": {
+      "types": "./build/common/error/index.d.js",
+      "import": "./build/common/error/index.js",
+      "require": "./build/common/error/index.js"
+    },
+    "./type": {
+      "types": "./build/common/type/data/index.d.js",
+      "import": "./build/common/type/data/index.js",
+      "require": "./build/common/type/data/index.js"
+    },
+    "./enum": {
+      "types": "./build/common/type/enum/index.d.js",
+      "import": "./build/common/type/enum/index.js",
+      "require": "./build/common/type/enum/index.js"
+    },
+    "./logger": {
+      "types": "./build/domain/service/basaltLogger.service.d.js",
+      "import": "./build/domain/service/basaltLogger.service.js",
+      "require": "./build/domain/service/basaltLogger.service.js"
+    },
+    "./strategy": {
+      "types": "./build/domain/service/strategy/index.d.js",
+      "import": "./build/domain/service/strategy/index.js",
+      "require": "./build/domain/service/strategy/index.js"
+    }
+  },
+  "scripts": {
+    "dev": "bun --watch source/index.ts",
+    "build": "tsc && tsc-alias && NODE_ENV=production bun bundler.config.ts",
+    "start": "NODE_ENV=production bun build/index.js",
+    "test": "bun test --coverage",
+    "docs": "typedoc",
+    "fix-lint": "eslint --fix ./source",
+    "lint": "eslint ./source"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Basalt-Lab/basalt-logger.git"
+  },
+  "keywords": [
+    "basalt-logger",
+    "basalt",
+    "logger"
+  ],
+  "author": "Ruby",
+  "license": "MIT",
+  "homepage": "https://github.com/Basalt-Lab/basalt-logger#readme",
+  "bugs": {
+    "url": "https://github.com/Basalt-Lab/basalt-logger/issues"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.13",
+    "@types/node": "^22.9.0",
+    "@eslint/js": "^9.14.0",
+    "@stylistic/eslint-plugin": "^2.10.1",
+    "eslint": "^9.14.0",
+    "eslint-plugin-tsdoc": "^0.3.0",
+    "globals": "^15.12.0",
+    "typescript-eslint": "^8.13.0",
+    "tsc-alias": "^1.8.10",
+    "tslib": "^2.8.1",
+    "typedoc": "^0.26.11",
+    "typescript": "^5.6.3"
+  }
+}