@mrxsys/mrx-core 2.11.0-1-and-267-20250925 → 2.11.1-1-and-275-20251023

package/dist/modules/kv-store/ioredis/ioredis-store.d.ts

@@ -11,97 +11,15 @@ export declare class IoRedisStore implements KvStore {
      * Redis client instance.
      */
     private readonly _client;
-    /**
-     * Creates an IoRedis store instance.
-     *
-     * @param options - Redis connection options
-     */
     constructor(options: RedisOptions);
-    /**
-     * Establishes connection to Redis server.
-     *
-     * @throws ({@link BaseError}) - When connection fails
-     */
     connect(): Promise<void>;
-    /**
-     * Closes the Redis connection gracefully.
-     *
-     * @throws ({@link BaseError}) - When closing connection fails
-     */
     close(): Promise<void>;
-    /**
-     * Retrieves a value from Redis by key.
-     *
-     * @template T - The expected type of the stored value
-     *
-     * @param key - The key to retrieve
-     *
-     * @returns The value associated with the key, or null if not found or expired
-     */
     get<T = unknown>(key: string): Promise<T | null>;
-    /**
-     * Stores a value in Redis with optional TTL.
-     *
-     * @template T - The type of the value being stored
-     *
-     * @param key - The key to store the value under
-     * @param value - The value to store
-     * @param ttlSec - Time to live in seconds (optional)
-     */
     set<T = unknown>(key: string, value: T, ttlSec?: number): Promise<void>;
-    /**
-     * Increments a numeric value stored at key by the specified amount.
-     * If the key does not exist, it is set to 0 before performing the operation.
-     *
-     * @param key - The key containing the numeric value
-     * @param amount - The amount to increment by (default: 1)
-     *
-     * @throws ({@link BaseError}) - When the value is not a valid integer
-     *
-     * @returns The value after incrementing
-     */
     increment(key: string, amount?: number): Promise<number>;
-    /**
-     * Decrements a numeric value stored at key by the specified amount.
-     * If the key does not exist, it is set to 0 before performing the operation.
-     *
-     * @param key - The key containing the numeric value
-     * @param amount - The amount to decrement by (default: 1)
-     *
-     * @throws ({@link BaseError}) - When the value is not a valid integer
-     *
-     * @returns The value after decrementing
-     */
     decrement(key: string, amount?: number): Promise<number>;
-    /**
-     * Deletes a key from Redis.
-     *
-     * @param key - The key to delete
-     *
-     * @returns True if the key was deleted, false if it did not exist
-     */
     del(key: string): Promise<boolean>;
-    /**
-     * Sets an expiration time for a key.
-     *
-     * @param key - The key to set expiration for
-     * @param ttlSec - Time to live in seconds
-     *
-     * @returns True if the expiration was set, false if the key does not exist
-     */
     expire(key: string, ttlSec: number): Promise<boolean>;
-    /**
-     * Gets the remaining time to live for a key.
-     *
-     * @param key - The key to check
-     *
-     * @returns Time to live in seconds, -1 if key has no expiration, -2 if key does not exist
-     */
     ttl(key: string): Promise<number>;
-    /**
-     * Removes all keys from the Redis database.
-     *
-     * @returns The number of keys that were deleted
-     */
     clean(): Promise<number>;
 }

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

@@ -1,9 +1,103 @@
 // @bun
 import {
-  MemoryStore
-} from "../../../chunk-e30paw8a.js";
-import"../../../chunk-xhhj1gvj.js";
-import"../../../chunk-9cgzhc50.js";
+  KV_STORE_ERROR_KEYS
+} from "../../../chunk-xhhj1gvj.js";
+import {
+  BaseError
+} from "../../../chunk-9cgzhc50.js";
+
+// source/modules/kv-store/memory/memory-store.ts
+class MemoryStore {
+  _store = new Map;
+  _cleanupInterval;
+  _cleanupTimer = null;
+  constructor(cleanupIntervalMs) {
+    this._cleanupInterval = cleanupIntervalMs ?? 300000;
+    this._startCleanup();
+  }
+  get(key) {
+    const entry = this._store.get(key);
+    if (!entry)
+      return null;
+    const now = Date.now();
+    if (now > entry.expiresAt && entry.expiresAt !== -1) {
+      this._store.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  set(key, value, ttlSec) {
+    const expiresAt = ttlSec ? Date.now() + ttlSec * 1000 : -1;
+    this._store.set(key, { value, expiresAt });
+  }
+  increment(key, amount = 1) {
+    const current = this.get(key);
+    const entry = this._store.get(key);
+    if (current !== null && typeof current !== "number")
+      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER);
+    const currentValue = current ?? 0;
+    const newValue = currentValue + amount;
+    const expiresAt = entry ? entry.expiresAt : -1;
+    this._store.set(key, { value: newValue, expiresAt });
+    return newValue;
+  }
+  decrement(key, amount = 1) {
+    const current = this.get(key);
+    const entry = this._store.get(key);
+    if (current !== null && typeof current !== "number")
+      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER);
+    const currentValue = current ?? 0;
+    const newValue = currentValue - amount;
+    const expiresAt = entry ? entry.expiresAt : -1;
+    this._store.set(key, { value: newValue, expiresAt });
+    return newValue;
+  }
+  del(key) {
+    return this._store.delete(key);
+  }
+  expire(key, ttlSec) {
+    const entry = this._store.get(key);
+    if (!entry)
+      return false;
+    entry.expiresAt = Date.now() + ttlSec * 1000;
+    return true;
+  }
+  ttl(key) {
+    const entry = this._store.get(key);
+    if (!entry)
+      return -1;
+    if (entry.expiresAt === -1)
+      return -1;
+    const remaining = entry.expiresAt - Date.now();
+    return remaining > 0 ? Math.ceil(remaining / 1000) : -1;
+  }
+  clean() {
+    const sizeBefore = this._store.size;
+    this._store.clear();
+    return sizeBefore;
+  }
+  _startCleanup() {
+    if (this._cleanupTimer)
+      return;
+    this._cleanupTimer = setInterval(() => {
+      this._removeExpiredEntries();
+    }, this._cleanupInterval);
+  }
+  _removeExpiredEntries() {
+    const now = Date.now();
+    for (const [key, entry] of this._store.entries())
+      if (entry.expiresAt !== -1 && now > entry.expiresAt)
+        this._store.delete(key);
+  }
+  destroy() {
+    if (this._cleanupTimer) {
+      clearInterval(this._cleanupTimer);
+      this._cleanupTimer = null;
+    }
+    this._store.clear();
+  }
+}
 export {
   MemoryStore
 };
+export { MemoryStore };

package/dist/modules/kv-store/memory/memory-store.d.ts

@@ -20,100 +20,16 @@ export declare class MemoryStore implements KvStore {
      * Timer for cleanup operations.
      */
     private _cleanupTimer;
-    /**
-     * Creates instance and starts cleanup process.
-     *
-     * @param cleanupIntervalMs - Cleanup interval in milliseconds (default: 300000 ms / 5 minutes)
-     */
     constructor(cleanupIntervalMs?: number);
-    /**
-     * Retrieves a value from the store by key.
-     * Automatically removes expired entries during retrieval.
-     *
-     * @template T - The expected type of the stored value
-     *
-     * @param key - The key to retrieve
-     *
-     * @returns The value associated with the key, or null if not found or expired
-     */
     get<T = unknown>(key: string): T | null;
-    /**
-     * Stores a value in memory with optional TTL.
-     *
-     * @template T - The type of the value being stored
-     *
-     * @param key - The key to store the value under
-     * @param value - The value to store
-     * @param ttlSec - Time to live in seconds (optional)
-     */
     set<T = unknown>(key: string, value: T, ttlSec?: number): void;
-    /**
-     * Increments a numeric value stored at key by the specified amount.
-     * If the key does not exist, it is set to 0 before performing the operation.
-     * Preserves existing TTL when incrementing.
-     *
-     * @param key - The key containing the numeric value
-     * @param amount - The amount to increment by (default: 1)
-     *
-     * @throws ({@link BaseError}) - When the value is not a valid integer
-     *
-     * @returns The value after incrementing
-     */
     increment(key: string, amount?: number): number;
-    /**
-     * Decrements a numeric value stored at key by the specified amount.
-     * If the key does not exist, it is set to 0 before performing the operation.
-     * Preserves existing TTL when decrementing.
-     *
-     * @param key - The key containing the numeric value
-     * @param amount - The amount to decrement by (default: 1)
-     *
-     * @throws ({@link BaseError}) - When the value is not a valid integer
-     *
-     * @returns The value after decrementing
-     */
     decrement(key: string, amount?: number): number;
-    /**
-     * Deletes a key from the store.
-     *
-     * @param key - The key to delete
-     *
-     * @returns True if the key was deleted, false if it did not exist
-     */
     del(key: string): boolean;
-    /**
-     * Sets an expiration time for a key.
-     *
-     * @param key - The key to set expiration for
-     * @param ttlSec - Time to live in seconds
-     *
-     * @returns True if the expiration was set, false if the key does not exist
-     */
     expire(key: string, ttlSec: number): boolean;
-    /**
-     * Gets the remaining time to live for a key.
-     *
-     * @param key - The key to check
-     *
-     * @returns Time to live in seconds, -1 if key has no expiration or does not exist
-     */
     ttl(key: string): number;
-    /**
-     * Removes all keys from the store.
-     *
-     * @returns The number of keys that were deleted
-     */
     clean(): number;
-    /**
-     * Starts the cleanup process for expired entries.
-     */
     private _startCleanup;
-    /**
-     * Removes expired entries from the store.
-     */
     private _removeExpiredEntries;
-    /**
-     * Stops the cleanup process and clears resources.
-     */
     destroy(): void;
 }

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

@@ -2,11 +2,11 @@ export interface KvStore {
     /**
      * Connect to the store.
      */
-    connect?(): Promise<void>;
+    connect?(): Promise<void> | void;
     /**
      * Close the connection to the store.
      */
-    close?(): Promise<void>;
+    close?(): Promise<void> | void;
     /**
      * Get the value associated with a key.
      *

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

@@ -1,7 +1,7 @@
 // @bun
 import {
   LOGGER_ERROR_KEYS
-} from "../../../chunk-b96fm9ph.js";
+} from "../../../chunk-rz5p4j3p.js";
 export {
   LOGGER_ERROR_KEYS
 };

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

@@ -1,6 +1,9 @@
 export declare const LOGGER_ERROR_KEYS: {
-    readonly NO_SINK_ADDED: "mrx-core.logger.error.no_sink_added";
+    readonly BEFORE_EXIT_CLOSE_ERROR: "mrx-core.logger.error.before_exit_close_error";
+    readonly BEFORE_EXIT_FLUSH_ERROR: "mrx-core.logger.error.before_exit_flush_error";
+    readonly NO_SINKS_PROVIDED: "mrx-core.logger.error.no_sinks_provided";
+    readonly REGISTER_SINK_ERROR: "mrx-core.logger.error.register_sink_error";
     readonly SINK_ALREADY_ADDED: "mrx-core.logger.error.sink_already_added";
-    readonly SINK_ERROR: "mrx-core.logger.error.sink_error";
-    readonly SINK_NOT_FOUND: "mrx-core.logger.error.sink_not_found";
+    readonly SINK_CLOSE_ERROR: "mrx-core.logger.error.sink_close_error";
+    readonly SINK_LOG_ERROR: "mrx-core.logger.error.sink_log_error";
 };

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

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

package/dist/modules/logger/index.js

@@ -1,7 +1,7 @@
 // @bun
 import {
   LOGGER_ERROR_KEYS
-} from "../../chunk-b96fm9ph.js";
+} from "../../chunk-rz5p4j3p.js";
 import {
   TypedEventEmitter
 } from "../../chunk-mvrxngm7.js";
@@ -10,110 +10,202 @@ import {
 } from "../../chunk-9cgzhc50.js";
 
 // source/modules/logger/logger.ts
-import { once } from "events";
-import { Transform } from "stream";
 class Logger extends TypedEventEmitter {
   _sinks;
-  _logStream;
-  _pendingLogs = [];
+  _sinkKeys = [];
+  _worker;
   _maxPendingLogs;
+  _maxMessagesInFlight;
+  _batchSize;
+  _batchTimeout;
+  _autoEnd;
+  _flushOnBeforeExit;
+  _pendingLogs = [];
+  _messagesInFlight = 0;
+  _batchTimer = null;
   _isWriting = false;
-  constructor(sinks = {}, maxPendingLogs = 1e4) {
+  _flushResolvers = [];
+  _closeResolver = null;
+  _backpressureResolver = null;
+  _handleExit = () => {
+    this._worker.terminate();
+  };
+  _handleWorkerClose = () => {
+    process.off("beforeExit", this._handleBeforeExit);
+    process.off("exit", this._handleExit);
+  };
+  constructor(options) {
     super();
-    this._sinks = sinks;
+    const {
+      autoEnd = true,
+      batchSize = 50,
+      batchTimeout = 0.1,
+      flushOnBeforeExit = true,
+      maxMessagesInFlight = 100,
+      maxPendingLogs = 1e4
+    } = options ?? {};
+    this._sinks = {};
     this._maxPendingLogs = maxPendingLogs;
-    this._logStream = new Transform({
-      objectMode: true,
-      transform: (chunk, _, callback) => {
-        this._executeStrategies(chunk.level, new Date(chunk.date), chunk.object, chunk.sinksNames).then(() => callback()).catch((error) => {
-          this.emit("error", error);
-          callback();
-        });
-      }
-    });
-  }
-  registerSink(name, sink) {
-    if (this._sinks[name])
-      throw new BaseError(LOGGER_ERROR_KEYS.SINK_ALREADY_ADDED, { sinkName: name });
-    return new Logger({
-      ...this._sinks,
-      [name]: sink
-    }, this._maxPendingLogs);
-  }
-  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);
-  }
-  registerSinks(sinks) {
-    return sinks.reduce((logger, [name, sink]) => logger.registerSink(name, sink), this);
+    this._maxMessagesInFlight = maxMessagesInFlight;
+    this._batchSize = batchSize;
+    this._batchTimeout = batchTimeout;
+    this._autoEnd = autoEnd;
+    this._flushOnBeforeExit = flushOnBeforeExit;
+    this._worker = new Worker(new URL("worker-logger.ts", import.meta.url).href, { type: "module" });
+    this._setupWorkerMessages();
+    if (this._autoEnd)
+      this._setupAutoEnd();
   }
-  unregisterSinks(names) {
-    let logger = this;
-    for (const name of names)
-      logger = logger.unregisterSink(name);
-    return logger;
-  }
-  clearSinks() {
-    return new Logger({}, this._maxPendingLogs);
+  registerSink(sinkName, sinkConstructor, ...sinkArgs) {
+    if (this._sinks[sinkName])
+      throw new Error(LOGGER_ERROR_KEYS.SINK_ALREADY_ADDED);
+    this._worker.postMessage({
+      type: "REGISTER_SINK",
+      sinkName,
+      sinkClassName: sinkConstructor.name,
+      sinkClassString: sinkConstructor.toString(),
+      sinkArgs
+    });
+    this._sinks[sinkName] = sinkConstructor;
+    this._sinkKeys.push(sinkName);
+    return this;
   }
-  error(object, sinksNames) {
-    this._out("ERROR", object, sinksNames);
+  error(object, sinkNames) {
+    this._enqueue("ERROR", object, sinkNames);
   }
-  warn(object, sinksNames) {
-    this._out("WARN", object, sinksNames);
+  warn(object, sinkNames) {
+    this._enqueue("WARN", object, sinkNames);
   }
-  info(object, sinksNames) {
-    this._out("INFO", object, sinksNames);
+  info(object, sinkNames) {
+    this._enqueue("INFO", object, sinkNames);
   }
-  debug(object, sinksNames) {
-    this._out("DEBUG", object, sinksNames);
+  debug(object, sinkNames) {
+    this._enqueue("DEBUG", object, sinkNames);
   }
-  log(object, sinksNames) {
-    this._out("LOG", object, sinksNames);
+  log(object, sinkNames = Object.keys(this._sinks)) {
+    this._enqueue("LOG", object, sinkNames);
   }
-  async _executeStrategies(level, date, object, sinksNames) {
-    await Promise.all(sinksNames.map(async (name) => {
-      try {
-        await this._sinks[name]?.log(level, date, object);
-      } catch (error) {
-        throw new BaseError(LOGGER_ERROR_KEYS.SINK_ERROR, { sinkName: name, object, error });
+  async flush() {
+    if (this._pendingLogs.length === 0 && this._messagesInFlight === 0)
+      return;
+    return new Promise((resolve) => {
+      this._flushResolvers.push(resolve);
+      if (!this._isWriting && this._pendingLogs.length > 0) {
+        this._isWriting = true;
+        this._processPendingLogs();
       }
-    }));
+    });
   }
-  _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 });
+  async close() {
+    await this.flush();
+    return new Promise((resolve) => {
+      this._closeResolver = resolve;
+      this._worker.postMessage({ type: "CLOSE" });
+    });
+  }
+  _enqueue(level, object, sinkNames) {
+    if (this._sinkKeys.length === 0)
+      throw new BaseError(LOGGER_ERROR_KEYS.NO_SINKS_PROVIDED, { level, object });
     if (this._pendingLogs.length >= this._maxPendingLogs)
       return;
-    const log = {
-      date: new Date().toISOString(),
+    this._pendingLogs.push({
+      sinkNames: sinkNames ?? this._sinkKeys,
       level,
-      object,
-      sinksNames: sinksNames ? sinksNames : sinkKeys
-    };
-    this._pendingLogs.push(log);
-    if (!this._isWriting) {
-      this._isWriting = true;
-      setImmediate(() => {
-        this._writeLog();
-      });
+      timestamp: Date.now(),
+      object
+    });
+    if (this._pendingLogs.length >= this._batchSize) {
+      if (this._batchTimer !== null) {
+        clearTimeout(this._batchTimer);
+        this._batchTimer = null;
+      }
+      this._triggerProcessing();
+    } else if (this._batchTimeout > 0 && this._batchTimer === null) {
+      this._batchTimer = setTimeout(() => {
+        this._batchTimer = null;
+        this._triggerProcessing();
+      }, this._batchTimeout);
     }
   }
-  async _writeLog() {
+  _triggerProcessing() {
+    if (this._isWriting)
+      return;
+    this._isWriting = true;
+    this._processPendingLogs();
+  }
+  async _processPendingLogs() {
     while (this._pendingLogs.length > 0) {
-      const pendingLog = this._pendingLogs.shift();
-      if (!pendingLog)
-        continue;
-      const canWrite = this._logStream.write(pendingLog);
-      if (!canWrite)
-        await once(this._logStream, "drain");
+      if (this._messagesInFlight >= this._maxMessagesInFlight)
+        await new Promise((resolve) => {
+          this._backpressureResolver = resolve;
+        });
+      const batch = this._pendingLogs.splice(0, this._batchSize);
+      this._messagesInFlight++;
+      this._worker.postMessage({
+        type: "LOG_BATCH",
+        logs: batch
+      });
     }
     this._isWriting = false;
-    this.emit("end");
+    this.emit("drained");
+  }
+  _releaseBatch() {
+    this._messagesInFlight--;
+    if (this._backpressureResolver !== null) {
+      this._backpressureResolver();
+      this._backpressureResolver = null;
+    }
+  }
+  _setupWorkerMessages() {
+    this._worker.addEventListener("message", (event) => {
+      switch (event.data.type) {
+        case "BATCH_COMPLETE":
+          this._releaseBatch();
+          if (this._messagesInFlight === 0 && this._pendingLogs.length === 0 && this._flushResolvers.length > 0) {
+            for (const resolve of this._flushResolvers)
+              resolve();
+            this._flushResolvers.length = 0;
+          }
+          break;
+        case "SINK_LOG_ERROR":
+          this.emit("sinkError", new BaseError(LOGGER_ERROR_KEYS.SINK_LOG_ERROR, event.data));
+          this._releaseBatch();
+          break;
+        case "SINK_CLOSE_ERROR":
+          this.emit("sinkError", new BaseError(LOGGER_ERROR_KEYS.SINK_CLOSE_ERROR, event.data));
+          break;
+        case "REGISTER_SINK_ERROR":
+          this.emit("registerSinkError", new BaseError(LOGGER_ERROR_KEYS.REGISTER_SINK_ERROR, event.data));
+          break;
+        case "CLOSE_COMPLETE":
+          this._worker.terminate();
+          if (this._closeResolver) {
+            this._closeResolver();
+            this._closeResolver = null;
+          }
+          break;
+      }
+    });
   }
+  _setupAutoEnd() {
+    process.on("beforeExit", this._handleBeforeExit);
+    process.on("exit", this._handleExit);
+    this._worker.addEventListener("close", this._handleWorkerClose);
+  }
+  _handleBeforeExit = () => {
+    if (this._flushOnBeforeExit)
+      this.flush().then(() => this.close()).catch((error) => {
+        this.emit("onBeforeExitError", new BaseError(LOGGER_ERROR_KEYS.BEFORE_EXIT_FLUSH_ERROR, {
+          error: error instanceof Error ? error : new Error("Unknown error during logger flush on beforeExit")
+        }));
+      });
+    else
+      this.close().catch((error) => {
+        this.emit("onBeforeExitError", new BaseError(LOGGER_ERROR_KEYS.BEFORE_EXIT_CLOSE_ERROR, {
+          error: error instanceof Error ? error : new Error("Unknown error during logger close on beforeExit")
+        }));
+      });
+  };
 }
 export {
   Logger