@mrxsys/mrx-core 2.8.0 → 2.9.0

package/dist/modules/kv-store/memory/index.js

@@ -0,0 +1,9 @@
+// @bun
+import {
+  MemoryStore
+} from "../../../chunk-k9dtqf1p.js";
+import"../../../chunk-6tqh339a.js";
+import"../../../chunk-9cgzhc50.js";
+export {
+  MemoryStore
+};

package/dist/modules/{kvStore/memory/memoryStore.d.ts → kv-store/memory/memory-store.d.ts}

@@ -1,4 +1,4 @@
-import type { KvStore } from '../../../modules/kvStore/types/kvStore';
+import type { KvStore } from '../../../modules/kv-store/types/kv-store';
 /**
  * In-memory key-value store implementation with automatic cleanup of expired entries.
  *

package/dist/modules/kv-store/types/index.d.ts

@@ -0,0 +1 @@
+export type { KvStore } from './kv-store';

package/dist/modules/logger/enums/index.d.ts

@@ -1 +1 @@
-export { LOGGER_ERROR_KEYS } from './loggerErrorKeys';
+export { LOGGER_ERROR_KEYS } from './logger-error-keys';

package/dist/modules/logger/enums/index.js

@@ -1,7 +1,7 @@
 // @bun
 import {
   LOGGER_ERROR_KEYS
-} from "../../../chunk-4xs0e8cm.js";
+} from "../../../chunk-547mr88s.js";
 export {
   LOGGER_ERROR_KEYS
 };

package/dist/modules/logger/enums/logger-error-keys.d.ts

@@ -0,0 +1,6 @@
+export declare const LOGGER_ERROR_KEYS: {
+    readonly NO_SINK_ADDED: "logger.error.no_sink_added";
+    readonly SINK_ALREADY_ADDED: "logger.error.sink_already_added";
+    readonly SINK_ERROR: "logger.error.sink_error";
+    readonly SINK_NOT_FOUND: "logger.error.sink_not_found";
+};

package/dist/modules/logger/events/index.d.ts

@@ -1 +1 @@
-export type { LoggerEvent } from './loggerEvents';
+export type { LoggerEvent } from './logger-events';

package/dist/modules/logger/events/logger-events.d.ts

@@ -0,0 +1,11 @@
+import type { BaseError } from '../../../errors/base-error';
+export interface LoggerEvent {
+    error: [
+        BaseError<{
+            sinkName: string;
+            object: unknown;
+            error: Error;
+        }>
+    ];
+    end: [];
+}

package/dist/modules/logger/index.js

@@ -1,110 +1,98 @@
 // @bun
 import {
   LOGGER_ERROR_KEYS
-} from "../../chunk-4xs0e8cm.js";
+} from "../../chunk-547mr88s.js";
 import {
   TypedEventEmitter
-} from "../../chunk-yvyahr2h.js";
+} from "../../chunk-mvrxngm7.js";
 import {
   BaseError
-} from "../../chunk-vknq69e0.js";
+} from "../../chunk-9cgzhc50.js";
 
 // source/modules/logger/logger.ts
 import { once } from "events";
 import { Transform } from "stream";
 class Logger extends TypedEventEmitter {
-  _strategies;
+  _sinks;
   _logStream;
   _pendingLogs = [];
   _maxPendingLogs;
   _isWriting = false;
-  constructor(strategies = {}, maxPendingLogs = 1e4) {
+  constructor(sinks = {}, maxPendingLogs = 1e4) {
     super();
-    this._strategies = strategies;
+    this._sinks = sinks;
     this._maxPendingLogs = maxPendingLogs;
     this._logStream = new Transform({
       objectMode: true,
       transform: (chunk, _, callback) => {
-        this._executeStrategies(chunk.level, new Date(chunk.date), chunk.object, chunk.strategiesNames).then(() => callback()).catch((error) => {
+        this._executeStrategies(chunk.level, new Date(chunk.date), chunk.object, chunk.sinksNames).then(() => callback()).catch((error) => {
           this.emit("error", error);
           callback();
         });
       }
     });
   }
-  registerStrategy(name, strategy) {
-    if (this._strategies[name])
-      throw new BaseError({
-        message: LOGGER_ERROR_KEYS.STRATEGY_ALREADY_ADDED,
-        cause: { strategyName: name }
-      });
+  registerSink(name, sink) {
+    if (this._sinks[name])
+      throw new BaseError(LOGGER_ERROR_KEYS.SINK_ALREADY_ADDED, { sinkName: name });
     return new Logger({
-      ...this._strategies,
-      [name]: strategy
+      ...this._sinks,
+      [name]: sink
     }, this._maxPendingLogs);
   }
-  unregisterStrategy(name) {
-    if (!(name in this._strategies))
-      throw new BaseError({
-        message: LOGGER_ERROR_KEYS.STRATEGY_NOT_FOUND,
-        cause: { strategyName: name }
-      });
-    const { [name]: _, ...rest } = this._strategies;
+  unregisterSink(name) {
+    if (!(name in this._sinks))
+      throw new BaseError(LOGGER_ERROR_KEYS.SINK_NOT_FOUND, { sinkName: name });
+    const { [name]: _, ...rest } = this._sinks;
     return new Logger(rest, this._maxPendingLogs);
   }
-  registerStrategies(strategies) {
-    return strategies.reduce((logger, [name, strategy]) => logger.registerStrategy(name, strategy), this);
+  registerSinks(sinks) {
+    return sinks.reduce((logger, [name, sink]) => logger.registerSink(name, sink), this);
   }
-  unregisterStrategies(names) {
+  unregisterSinks(names) {
     let logger = this;
     for (const name of names)
-      logger = logger.unregisterStrategy(name);
+      logger = logger.unregisterSink(name);
     return logger;
   }
-  clearStrategies() {
+  clearSinks() {
     return new Logger({}, this._maxPendingLogs);
   }
-  error(object, strategiesNames) {
-    this._out("ERROR", object, strategiesNames);
+  error(object, sinksNames) {
+    this._out("ERROR", object, sinksNames);
   }
-  warn(object, strategiesNames) {
-    this._out("WARN", object, strategiesNames);
+  warn(object, sinksNames) {
+    this._out("WARN", object, sinksNames);
   }
-  info(object, strategiesNames) {
-    this._out("INFO", object, strategiesNames);
+  info(object, sinksNames) {
+    this._out("INFO", object, sinksNames);
   }
-  debug(object, strategiesNames) {
-    this._out("DEBUG", object, strategiesNames);
+  debug(object, sinksNames) {
+    this._out("DEBUG", object, sinksNames);
   }
-  log(object, strategiesNames) {
-    this._out("LOG", object, strategiesNames);
+  log(object, sinksNames) {
+    this._out("LOG", object, sinksNames);
   }
-  async _executeStrategies(level, date, object, strategiesNames) {
-    await Promise.all(strategiesNames.map(async (name) => {
+  async _executeStrategies(level, date, object, sinksNames) {
+    await Promise.all(sinksNames.map(async (name) => {
       try {
-        await this._strategies[name]?.log(level, date, object);
+        await this._sinks[name]?.log(level, date, object);
       } catch (error) {
-        throw new BaseError({
-          message: LOGGER_ERROR_KEYS.STRATEGY_ERROR,
-          cause: { strategyName: name, object, error }
-        });
+        throw new BaseError(LOGGER_ERROR_KEYS.SINK_ERROR, { sinkName: name, object, error });
       }
     }));
   }
-  _out(level, object, strategiesNames) {
-    const strategyKeys = Object.keys(this._strategies);
-    if (strategyKeys.length === 0)
-      throw new BaseError({
-        message: LOGGER_ERROR_KEYS.NO_STRATEGY_ADDED,
-        cause: { level, object }
-      });
+  _out(level, object, sinksNames) {
+    const sinkKeys = Object.keys(this._sinks);
+    if (sinkKeys.length === 0)
+      throw new BaseError(LOGGER_ERROR_KEYS.NO_SINK_ADDED, { level, object });
     if (this._pendingLogs.length >= this._maxPendingLogs)
       return;
     const log = {
       date: new Date().toISOString(),
       level,
       object,
-      strategiesNames: strategiesNames ? strategiesNames : strategyKeys
+      sinksNames: sinksNames ? sinksNames : sinkKeys
     };
     this._pendingLogs.push(log);
     if (!this._isWriting) {

package/dist/modules/logger/logger.d.ts

@@ -1,189 +1,189 @@
-import { TypedEventEmitter } from '../../modules/typedEventEmitter/typedEventEmitter';
-import type { LoggerEvent } from './events/loggerEvents';
-import type { BodiesIntersection } from './types/bodiesIntersection';
-import type { LoggerStrategy } from './types/loggerStrategy';
-import type { StrategyMap } from './types/strategyMap';
+import { TypedEventEmitter } from '../../modules/typed-event-emitter/typed-event-emitter';
+import type { LoggerEvent } from './events/logger-events';
+import type { BodiesIntersection } from './types/bodies-intersection';
+import type { LoggerSink } from './types/logger-sink';
+import type { SinkMap } from './types/sink-map';
 /**
-* Logger provides a flexible, type-safe logging system that allows multiple strategies for log output.
-* The logger uses a transform stream to process log entries and execute the logging strategies.
-*
-* Logger extends the TypedEventEmitter class to emit typed events when an error occurs or when the logger ends.
-* The logger can log messages with different levels: error, warn, info, debug, and log.
-*
-* @template TStrategies - The map of strategy names to LoggerStrategy types.
-*/
-export declare class Logger<TStrategies extends StrategyMap = {}> extends TypedEventEmitter<LoggerEvent> {
-    /**
-    * The map of strategies.
-    */
-    private readonly _strategies;
-    /**
-    * The transform stream for processing log entries.
-    */
+ * Logger provides a flexible, type-safe logging system that allows multiple sinks for log output.
+ * The logger uses a transform stream to process log entries and execute the logging sinks.
+ *
+ * Logger extends the TypedEventEmitter class to emit typed events when an error occurs or when the logger ends.
+ * The logger can log messages with different levels: error, warn, info, debug, and log.
+ *
+ * @template TSinks - The map of sink names to LoggerStrategy types.
+ */
+export declare class Logger<TSinks extends SinkMap = {}> extends TypedEventEmitter<LoggerEvent> {
+    /**
+     * The map of sinks.
+     */
+    private readonly _sinks;
+    /**
+     * The transform stream for processing log entries.
+     */
     private readonly _logStream;
     /**
-    * The queue of pending log entries.
-    */
+     * The queue of pending log entries.
+     */
     private readonly _pendingLogs;
     /**
-    * The maximum number of pending logs.
-    * @defaultValue 10_000
-    */
+     * The maximum number of pending logs.
+     * @defaultValue 10_000
+     */
     private readonly _maxPendingLogs;
     /**
-    * Flag to indicate if the logger is currently writing logs.
-    */
+     * Flag to indicate if the logger is currently writing logs.
+     */
     private _isWriting;
     /**
-    * Construct a Logger.
-    *
-    * @template TStrategies - The map of strategy names to LoggerStrategy types.
-    *
-    * @param strategies - Initial strategies map.
-    *
-    * @param maxPendingLogs - Maximum number of logs in the queue (default: 10_000)
-    */
-    constructor(strategies?: TStrategies, maxPendingLogs?: number);
-    /**
-    * Register a new logging strategy.
-    *
-    * @template Key - The name of the strategy.
-    * @template Strategy - The strategy type.
-    *
-    * @param name - The name of the strategy.
-    * @param strategy - The strategy to add. It must implement {@link LoggerStrategy}.
-    *
-    * @throws ({@link BaseError}) - If the strategy is already added.
-    *
-    * @returns A new Logger instance with the added strategy.
-    */
-    registerStrategy<Key extends string, Strategy extends LoggerStrategy>(name: Key, strategy: Strategy): Logger<TStrategies & Record<Key, Strategy>>;
-    /**
-    * Unregister a logging strategy.
-    *
-    * @template Key - The name of the strategy.
-    *
-    * @param name - The name of the strategy to remove.
-    *
-    * @throws ({@link BaseError}) - If the strategy is not found.
-    *
-    * @returns A new Logger instance without the removed strategy.
-    */
-    unregisterStrategy<Key extends keyof TStrategies>(name: Key): Logger<Omit<TStrategies, Key>>;
-    /**
-    * Register multiple strategies at once.
-    *
-    * @template TNew - The new strategies to add.
-    *
-    * @param strategies - An array of tuples where each tuple contains the strategy name and the strategy instance.
-    *
-    * @throws ({@link BaseError}) - If any strategy is already added.
-    *
-    * @returns A new Logger instance with the added strategies.
-    */
-    registerStrategies<TNew extends [string, LoggerStrategy][] = [string, LoggerStrategy][]>(strategies: TNew): Logger<TStrategies & {
-        [K in TNew[number][0]]: Extract<TNew[number], [K, LoggerStrategy]>[1];
+     * Construct a Logger.
+     *
+     * @template TStrategies - The map of sink names to LoggerStrategy types.
+     *
+     * @param sinks - Initial sinks map.
+     *
+     * @param maxPendingLogs - Maximum number of logs in the queue (default: 10_000)
+     */
+    constructor(sinks?: TSinks, maxPendingLogs?: number);
+    /**
+     * Register a new logging sink.
+     *
+     * @template Key - The name of the sink.
+     * @template Sink - The sink type.
+     *
+     * @param name - The name of the sink.
+     * @param sink - The sink to add. It must implement {@link LoggerSink}.
+     *
+     * @throws ({@link BaseError}) - If the sink is already added.
+     *
+     * @returns A new Logger instance with the added sink.
+     */
+    registerSink<Key extends string, Sink extends LoggerSink>(name: Key, sink: Sink): Logger<TSinks & Record<Key, Sink>>;
+    /**
+     * Unregister a logging sink.
+     *
+     * @template Key - The name of the sink.
+     *
+     * @param name - The name of the sink to remove.
+     *
+     * @throws ({@link BaseError}) - If the sink is not found.
+     *
+     * @returns A new Logger instance without the removed sink.
+     */
+    unregisterSink<Key extends keyof TSinks>(name: Key): Logger<Omit<TSinks, Key>>;
+    /**
+     * Register multiple sinks at once.
+     *
+     * @template TNew - The new sinks to add.
+     *
+     * @param sinks - An array of tuples where each tuple contains the sink name and the sink instance.
+     *
+     * @throws ({@link BaseError}) - If any sink is already added.
+     *
+     * @returns A new Logger instance with the added sinks.
+     */
+    registerSinks<TNew extends [string, LoggerSink][] = [string, LoggerSink][]>(sinks: TNew): Logger<TSinks & {
+        [K in TNew[number][0]]: Extract<TNew[number], [K, LoggerSink]>[1];
     }>;
     /**
-    * Unregister multiple strategies at once.
-    *
-    * @template Keys - The names of the strategies to remove.
-    *
-    * @param names - An array of strategy names to remove.
-    *
-    * @throws ({@link BaseError}) - If any strategy is not found.
-    *
-    * @returns A new Logger instance without the removed strategies.
-    */
-    unregisterStrategies<Keys extends Extract<keyof TStrategies, string>>(names: Keys[]): Logger<Omit<TStrategies, Keys>>;
-    /**
-    * Remove all strategies.
-    *
-    * @returns A new Logger instance without any strategies.
-    */
-    clearStrategies(): Logger;
-    /**
-    * Log an error message.
-    *
-    * @template SNames - The names of the strategies to use.
-    *
-    * @param object - The object to log.
-    * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-    *
-    * @throws ({@link BaseError}) - If no strategy is added.
-    */
-    error<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-    * Log a warning message.
-    *
-    * @template SNames - The names of the strategies to use.
-    *
-    * @param object - The object to log.
-    * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-    *
-    * @throws ({@link BaseError}) - If no strategy is added.
-    */
-    warn<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-    * Log an info message.
-    *
-    * @template SNames - The names of the strategies to use.
-    *
-    * @param object - The object to log.
-    * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-    *
-    * @throws ({@link BaseError}) - If no strategy is added.
-    */
-    info<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-    * Log a debug message.
-    *
-    * @template SNames - The names of the strategies to use.
-    *
-    * @param object - The object to log.
-    * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-    *
-    * @throws ({@link BaseError}) - If no strategy is added.
-    */
-    debug<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-    * Log a generic message.
-    *
-    * @template SNames - The names of the strategies to use.
-    *
-    * @param object - The object to log.
-    * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-    *
-    * @throws ({@link BaseError}) - If no strategy is added.
-    */
-    log<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-    * Internal: execute all strategies for a log event.
-    *
-    * @template TLogObject - The type of the log object.
-    *
-    * @param level - The log level.
-    * @param date - The date of the log event.
-    * @param object - The object to log.
-    * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-    *
-    * @throws ({@link BaseError}) - If a strategy throws.
-    */
+     * Unregister multiple sinks at once.
+     *
+     * @template Keys - The names of the sinks to remove.
+     *
+     * @param names - An array of sink names to remove.
+     *
+     * @throws ({@link BaseError}) - If any sink is not found.
+     *
+     * @returns A new Logger instance without the removed sinks.
+     */
+    unregisterSinks<Keys extends Extract<keyof TSinks, string>>(names: Keys[]): Logger<Omit<TSinks, Keys>>;
+    /**
+     * Remove all sinks.
+     *
+     * @returns A new Logger instance without any sinks.
+     */
+    clearSinks(): Logger;
+    /**
+     * Log an error message.
+     *
+     * @template SNames - The names of the sinks to use.
+     *
+     * @param object - The object to log.
+     * @param sinksNames - The names of the sinks to use. If not provided, all sinks will be used.
+     *
+     * @throws ({@link BaseError}) - If no sink is added.
+     */
+    error<SNames extends (keyof TSinks)[] = (keyof TSinks)[]>(object: BodiesIntersection<TSinks, SNames[number]>, sinksNames?: SNames): void;
+    /**
+     * Log a warning message.
+     *
+     * @template SNames - The names of the sinks to use.
+     *
+     * @param object - The object to log.
+     * @param sinksNames - The names of the sinks to use. If not provided, all sinks will be used.
+     *
+     * @throws ({@link BaseError}) - If no sink is added.
+     */
+    warn<SNames extends (keyof TSinks)[] = (keyof TSinks)[]>(object: BodiesIntersection<TSinks, SNames[number]>, sinksNames?: SNames): void;
+    /**
+     * Log an info message.
+     *
+     * @template SNames - The names of the sinks to use.
+     *
+     * @param object - The object to log.
+     * @param sinksNames - The names of the sinks to use. If not provided, all sinks will be used.
+     *
+     * @throws ({@link BaseError}) - If no sink is added.
+     */
+    info<SNames extends (keyof TSinks)[] = (keyof TSinks)[]>(object: BodiesIntersection<TSinks, SNames[number]>, sinksNames?: SNames): void;
+    /**
+     * Log a debug message.
+     *
+     * @template SNames - The names of the sinks to use.
+     *
+     * @param object - The object to log.
+     * @param sinksNames - The names of the sinks to use. If not provided, all sinks will be used.
+     *
+     * @throws ({@link BaseError}) - If no sink is added.
+     */
+    debug<SNames extends (keyof TSinks)[] = (keyof TSinks)[]>(object: BodiesIntersection<TSinks, SNames[number]>, sinksNames?: SNames): void;
+    /**
+     * Log a generic message.
+     *
+     * @template SNames - The names of the sinks to use.
+     *
+     * @param object - The object to log.
+     * @param sinksNames - The names of the sinks to use. If not provided, all sinks will be used.
+     *
+     * @throws ({@link BaseError}) - If no sink is added.
+     */
+    log<SNames extends (keyof TSinks)[] = (keyof TSinks)[]>(object: BodiesIntersection<TSinks, SNames[number]>, sinksNames?: SNames): void;
+    /**
+     * Internal: execute all sinks for a log event.
+     *
+     * @template TLogObject - The type of the log object.
+     *
+     * @param level - The log level.
+     * @param date - The date of the log event.
+     * @param object - The object to log.
+     * @param sinksNames - The names of the sinks to use. If not provided, all sinks will be used.
+     *
+     * @throws ({@link BaseError}) - If a sink throws.
+     */
     private _executeStrategies;
     /**
-    * Internal: queue a log event and start writing if not already.
-    *
-    * @template TLogObject - The type of the log object.
-    *
-    * @param level - The log level.
-    * @param object - The object to log.
-    * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-    *
-    * @throws ({@link BaseError}) - If no strategy is added.
-    */
+     * Internal: queue a log event and start writing if not already.
+     *
+     * @template TLogObject - The type of the log object.
+     *
+     * @param level - The log level.
+     * @param object - The object to log.
+     * @param sinksNames - The names of the sinks to use. If not provided, all sinks will be used.
+     *
+     * @throws ({@link BaseError}) - If no sink is added.
+     */
     private _out;
     /**
-    * Internal: process the log queue and emit 'end' when done.
-    */
+     * Internal: process the log queue and emit 'end' when done.
+     */
     private _writeLog;
 }

package/dist/modules/logger/sinks/console-logger.d.ts

@@ -0,0 +1,22 @@
+import type { LogLevels } from '../../../modules/logger/types/log-levels';
+import type { LoggerSink } from '../../../modules/logger/types/logger-sink';
+/**
+* ConsoleLoggerSink implements LoggerSink to provide logging functionality to the console.
+*/
+export declare class ConsoleLoggerSink implements LoggerSink {
+    private readonly _colorize;
+    /**
+    * Initializes the ConsoleLoggerSink.
+    *
+    * @param colorize - Indicates if the output should be colorized. (Default is false.)
+    */
+    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.
+    * @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/dist/modules/logger/sinks/file-logger.d.ts

@@ -0,0 +1,25 @@
+import type { LogLevels } from '../../../modules/logger/types/log-levels';
+import type { LoggerSink } from '../../../modules/logger/types/logger-sink';
+/**
+* FileLoggerSink implements LoggerSink to provide logging functionality to the file system.
+*/
+export declare class FileLoggerSink implements LoggerSink {
+    /**
+    * Path to the file to log to.
+    */
+    private readonly _path;
+    /**
+    * Constructor FileLoggerSink
+    *
+    * @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.
+    * @param date - The date at which the message was logged.
+    * @param object - The object to log.
+    */
+    log(level: LogLevels, date: Date, object: unknown): Promise<void>;
+}

package/dist/modules/logger/sinks/index.d.ts

@@ -0,0 +1,2 @@
+export { ConsoleLoggerSink } from './console-logger.ts';
+export { FileLoggerSink } from './file-logger.ts';