@mrxsys/mrx-core 2.7.0 → 2.9.0-1-and-259-20250918

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

@@ -0,0 +1,119 @@
+import type { KvStore } from '../../../modules/kv-store/types/kv-store';
+/**
+ * In-memory key-value store implementation with automatic cleanup of expired entries.
+ *
+ * Provides a memory-based implementation of the KvStore interface with TTL support
+ * and automatic background cleanup of expired entries.
+ */
+export declare class MemoryStore implements KvStore {
+    /**
+     * In-memory key-value store.
+     */
+    private readonly _store;
+    /**
+     * Cleanup interval (5 minutes by default).
+     *
+     * @defaultValue 300000
+     */
+    private readonly _cleanupInterval;
+    /**
+     * 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/{elysia/rateLimit/types/memoryStoreEntry.d.ts → kv-store/memory/types/memory-store-entry.d.ts}

@@ -2,10 +2,10 @@ export interface MemoryStoreEntry {
     /**
      * Current count value for the key.
      */
-    readonly value: string;
+    readonly value: unknown;
     /**
      * Timestamp when this entry expires (in milliseconds).
      * -1 means no expiration (like Redis behavior).
      */
-    readonly expiresAt: number;
+    expiresAt: number;
 }

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

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

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

@@ -0,0 +1,81 @@
+export interface KvStore {
+    /**
+     * Connect to the store.
+     */
+    connect?(): Promise<void>;
+    /**
+     * Close the connection to the store.
+     */
+    close?(): Promise<void>;
+    /**
+     * Get the value associated with a key.
+     *
+     * @template T - The type of the value to retrieve.
+     *
+     * @param key - The key to retrieve the value for.
+     *
+     * @returns The value associated with the key, or `null` if the key does not exist.
+     */
+    get<T = unknown>(key: string): T | null | Promise<T | null>;
+    /**
+     * Set the value associated with a key.
+     *
+     * @template T - The type of the value to set.
+     *
+     * @param key - The key to set the value for.
+     * @param value - The value to set.
+     * @param ttlSec - The time-to-live for the key, in seconds.
+     */
+    set<T = unknown>(key: string, value: T, ttlSec?: number): void | Promise<void>;
+    /**
+     * Increment the value associated with a key.
+     * Value needs to be a number.
+     *
+     * @param key - The key to increment the value for.
+     * @param amount - The amount to increment by.
+     *
+     * @returns The new value after incrementing.
+     */
+    increment(key: string, amount?: number): number | Promise<number>;
+    /**
+     * Decrement the value associated with a key.
+     * Value needs to be a number.
+     *
+     * @param key - The key to decrement the value for.
+     * @param amount - The amount to decrement by.
+     *
+     * @returns The new value after decrementing.
+     */
+    decrement(key: string, amount?: number): number | Promise<number>;
+    /**
+     * Delete a key from the store.
+     *
+     * @param key - The key to delete.
+     *
+     * @returns `true` if the key was deleted, `false` otherwise.
+     */
+    del(key: string): boolean | Promise<boolean>;
+    /**
+     * Set the expiration time for a key.
+     *
+     * @param key - The key to set the expiration for.
+     * @param ttlSec - The time-to-live for the key, in seconds.
+     *
+     * @returns `true` if the expiration was set, `false` otherwise.
+     */
+    expire(key: string, ttlSec: number): boolean | Promise<boolean>;
+    /**
+     * Get the remaining time-to-live for a key.
+     *
+     * @param key - The key to retrieve the TTL for.
+     *
+     * @returns The remaining time-to-live for the key, in seconds.
+     */
+    ttl(key: string): number | Promise<number>;
+    /**
+     * Clean all keys from the store.
+     *
+     * @returns The number of keys that were removed.
+     */
+    clean(): number | Promise<number>;
+}

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) {