@mrxsys/mrx-core 2.11.0-2-and-276-20251029 → 2.11.0-4-and-276-20251029

package/dist/modules/elysia/rate-limit/index.js

@@ -0,0 +1,81 @@
+// @bun
+import {
+  RATE_LIMIT_ERROR_KEYS
+} from "../../../chunk-dre2fgj0.js";
+import {
+  MemoryStore
+} from "../../../chunk-e30paw8a.js";
+import"../../../chunk-xhhj1gvj.js";
+import {
+  HttpError
+} from "../../../chunk-7t524zqh.js";
+import"../../../chunk-sqts8vyk.js";
+import"../../../chunk-9cgzhc50.js";
+
+// source/modules/elysia/rate-limit/rate-limit.ts
+import { Elysia } from "elysia";
+var rateLimit = (store) => {
+  const restrictedRoutes = new Map;
+  store = store || new MemoryStore;
+  const rateLimitCheck = async (key, limit, window, set) => {
+    if (set.headers["X-RateLimit-Limit"])
+      return;
+    let count = await store.get(key) ?? 0;
+    if (count === 0) {
+      await store.set(key, 1, window);
+      count = 1;
+    } else {
+      count = await store.increment(key);
+    }
+    const remaining = Math.max(0, limit - count);
+    const resetTime = await store.ttl(key);
+    set.headers = {
+      "X-RateLimit-Limit": limit.toString(),
+      "X-RateLimit-Remaining": remaining.toString(),
+      "X-RateLimit-Reset": resetTime.toString()
+    };
+    if (count > limit) {
+      set.status = 429;
+      throw new HttpError(RATE_LIMIT_ERROR_KEYS.RATE_LIMIT_EXCEEDED, "TOO_MANY_REQUESTS", {
+        limit,
+        window,
+        remaining: 0,
+        reset: resetTime
+      });
+    }
+  };
+  return new Elysia({
+    name: "rateLimit",
+    seed: {
+      store
+    }
+  }).macro({
+    rateLimit: ({ limit, window }) => ({
+      transform: ({ request }) => {
+        const route = `${request.method}:${new URL(request.url).pathname}`;
+        if (!restrictedRoutes.has(route)) {
+          restrictedRoutes.set(route, { limit, window });
+        } else if (restrictedRoutes.has(route)) {
+          const existing = restrictedRoutes.get(route);
+          if (limit != existing.limit || window != existing.window)
+            restrictedRoutes.set(route, {
+              limit,
+              window
+            });
+        }
+      },
+      beforeHandle: async ({ set, request, server }) => {
+        const route = `${request.method}:${new URL(request.url).pathname}`;
+        if (restrictedRoutes.has(route)) {
+          const { limit: limit2, window: window2 } = restrictedRoutes.get(route);
+          const ip = request.headers.get("x-forwarded-for") || request.headers.get("x-real-ip") || server?.requestIP(request)?.address || "127.0.0.1";
+          const key = `ratelimit:${route}:${ip}`;
+          await rateLimitCheck(key, limit2, window2, set);
+        }
+      }
+    })
+  }).as("global");
+};
+export {
+  rateLimit
+};

package/dist/modules/elysia/rate-limit/rate-limit.d.ts

@@ -1,4 +1,4 @@
-import type { KvStore } from '#/modules/kv-store/types/kv-store';
+import type { KvStore } from '../../../modules/kv-store/types/kv-store';
 import { Elysia, type HTTPHeaders, type StatusMap } from 'elysia';
 import type { RateLimitOptions } from './types/rate-limit-options';
 /**

package/dist/modules/elysia/rate-limit/types/index.js

@@ -0,0 +1 @@
+// @bun

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

@@ -0,0 +1,11 @@
+// @bun
+import {
+  JWT_ERROR_KEYS
+} from "../../../chunk-9d3zvgp6.js";
+import {
+  PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS
+} from "../../../chunk-12qzn7jw.js";
+export {
+  PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS,
+  JWT_ERROR_KEYS
+};

package/dist/modules/jwt/index.js

@@ -0,0 +1,51 @@
+// @bun
+import {
+  JWT_ERROR_KEYS
+} from "../../chunk-9d3zvgp6.js";
+import {
+  parseHumanTimeToSeconds
+} from "../../chunk-eeb7yskp.js";
+import"../../chunk-12qzn7jw.js";
+import {
+  HttpError
+} from "../../chunk-7t524zqh.js";
+import"../../chunk-sqts8vyk.js";
+import"../../chunk-9cgzhc50.js";
+
+// source/modules/jwt/jwt.ts
+import {
+  SignJWT,
+  jwtVerify
+} from "jose";
+var signJWT = (secret, payload, expiration = Math.floor(Date.now() / 1000) + 60 * 15) => {
+  const exp = expiration instanceof Date ? Math.floor(expiration.getTime() / 1000) : typeof expiration === "number" ? expiration : Math.floor(Date.now() / 1000) + parseHumanTimeToSeconds(expiration);
+  if (exp <= Math.floor(Date.now() / 1000))
+    throw new HttpError(JWT_ERROR_KEYS.JWT_EXPIRATION_PASSED, "BAD_REQUEST");
+  const finalPayload = {
+    iss: "Core-Issuer",
+    sub: "",
+    aud: ["Core-Audience"],
+    jti: Bun.randomUUIDv7(),
+    nbf: Math.floor(Date.now() / 1000),
+    iat: Math.floor(Date.now() / 1000),
+    exp,
+    ...payload
+  };
+  try {
+    const jwt = new SignJWT(finalPayload).setProtectedHeader({ alg: "HS256", typ: "JWT" }).setIssuer(finalPayload.iss).setSubject(finalPayload.sub).setAudience(finalPayload.aud).setJti(finalPayload.jti).setNotBefore(finalPayload.nbf).setIssuedAt(finalPayload.iat).setExpirationTime(expiration).sign(new TextEncoder().encode(secret));
+    return jwt;
+  } catch (error) {
+    throw new HttpError(JWT_ERROR_KEYS.JWT_SIGN_ERROR, "INTERNAL_SERVER_ERROR", error);
+  }
+};
+var verifyJWT = async (token, secret) => {
+  try {
+    return await jwtVerify(token, new TextEncoder().encode(secret));
+  } catch {
+    return false;
+  }
+};
+export {
+  verifyJWT,
+  signJWT
+};

package/dist/modules/jwt/utils/index.js

@@ -0,0 +1,9 @@
+// @bun
+import {
+  parseHumanTimeToSeconds
+} from "../../../chunk-eeb7yskp.js";
+import"../../../chunk-12qzn7jw.js";
+import"../../../chunk-9cgzhc50.js";
+export {
+  parseHumanTimeToSeconds
+};

package/dist/modules/kv-store/bun-redis/bun-redis-store.d.ts

@@ -1,5 +1,5 @@
 import { type RedisOptions } from 'bun';
-import type { KvStore } from '#/modules/kv-store/types/kv-store';
+import type { KvStore } from '../../../modules/kv-store/types/kv-store';
 /**
  * Redis-based key-value store implementation using Bun's Redis client.
  *

package/dist/modules/kv-store/bun-redis/index.js

@@ -0,0 +1,84 @@
+// @bun
+import {
+  KV_STORE_ERROR_KEYS
+} from "../../../chunk-xhhj1gvj.js";
+import {
+  BaseError
+} from "../../../chunk-9cgzhc50.js";
+
+// source/modules/kv-store/bun-redis/bun-redis-store.ts
+var {RedisClient } = globalThis.Bun;
+class BunRedisStore {
+  _client;
+  constructor(url, options) {
+    this._client = new RedisClient(url, options);
+  }
+  async connect() {
+    try {
+      await this._client.connect();
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.CONNECTION_FAILED, e);
+    }
+  }
+  close() {
+    try {
+      this._client.close();
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.CLOSING_CONNECTION_FAILED, e);
+    }
+  }
+  async get(key) {
+    const value = await this._client.get(key);
+    if (value === null)
+      return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  async set(key, value, ttlSec) {
+    const serialized = typeof value === "string" ? value : JSON.stringify(value);
+    if (ttlSec)
+      await this._client.set(key, serialized, "EX", ttlSec);
+    else
+      await this._client.set(key, serialized);
+  }
+  async increment(key, amount) {
+    try {
+      const number = await this._client.incrby(key, amount ?? 1);
+      return number;
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER, e);
+    }
+  }
+  async decrement(key, amount) {
+    try {
+      const number = await this._client.decrby(key, amount ?? 1);
+      return number;
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER, e);
+    }
+  }
+  async del(key) {
+    const res = await this._client.del(key);
+    return res === 1;
+  }
+  async expire(key, ttlSec) {
+    const res = await this._client.expire(key, ttlSec);
+    return res === 1;
+  }
+  async ttl(key) {
+    const res = await this._client.ttl(key);
+    return res;
+  }
+  async clean() {
+    const keys = await this._client.keys("*");
+    if (keys.length === 0)
+      return 0;
+    return this._client.del(...keys);
+  }
+}
+export {
+  BunRedisStore
+};

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

@@ -0,0 +1,7 @@
+// @bun
+import {
+  KV_STORE_ERROR_KEYS
+} from "../../../chunk-xhhj1gvj.js";
+export {
+  KV_STORE_ERROR_KEYS
+};

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

@@ -0,0 +1,86 @@
+// @bun
+import {
+  KV_STORE_ERROR_KEYS
+} from "../../../chunk-xhhj1gvj.js";
+import {
+  BaseError
+} from "../../../chunk-9cgzhc50.js";
+
+// source/modules/kv-store/ioredis/ioredis-store.ts
+import { Redis } from "ioredis";
+class IoRedisStore {
+  _client;
+  constructor(options) {
+    this._client = new Redis({
+      ...options,
+      lazyConnect: true
+    });
+  }
+  async connect() {
+    try {
+      await this._client.connect();
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.CONNECTION_FAILED, e);
+    }
+  }
+  async close() {
+    try {
+      await this._client.quit();
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.CLOSING_CONNECTION_FAILED, e);
+    }
+  }
+  async get(key) {
+    const value = await this._client.get(key);
+    if (value === null)
+      return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  async set(key, value, ttlSec) {
+    const serialized = typeof value === "string" ? value : JSON.stringify(value);
+    if (ttlSec)
+      await this._client.setex(key, ttlSec, serialized);
+    else
+      await this._client.set(key, serialized);
+  }
+  async increment(key, amount = 1) {
+    try {
+      const number = await this._client.incrby(key, amount);
+      return number;
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER, e);
+    }
+  }
+  async decrement(key, amount = 1) {
+    try {
+      const number = await this._client.decrby(key, amount);
+      return number;
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER, e);
+    }
+  }
+  async del(key) {
+    const result = await this._client.del(key);
+    return result === 1;
+  }
+  async expire(key, ttlSec) {
+    const result = await this._client.expire(key, ttlSec);
+    return result === 1;
+  }
+  ttl(key) {
+    return this._client.ttl(key);
+  }
+  async clean() {
+    const keys = await this._client.keys("*");
+    if (keys.length === 0)
+      return 0;
+    return this._client.del(...keys);
+  }
+}
+export {
+  IoRedisStore
+};

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

@@ -1,5 +1,5 @@
 import { type RedisOptions } from 'ioredis';
-import type { KvStore } from '#/modules/kv-store/types/kv-store';
+import type { KvStore } from '../../../modules/kv-store/types/kv-store';
 /**
  * Redis-based key-value store implementation using ioredis client.
  *

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

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

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

@@ -1,4 +1,4 @@
-import type { KvStore } from '#/modules/kv-store/types/kv-store';
+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.js

@@ -0,0 +1 @@
+// @bun

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

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

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

@@ -0,0 +1 @@
+// @bun

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

@@ -1,4 +1,4 @@
-import type { BaseError } from '#/errors/base-error';
+import type { BaseError } from '../../../errors/base-error';
 export interface LoggerEvent {
     onBeforeExitError: [BaseError<{
         error: Error;

package/dist/modules/logger/index.js

@@ -0,0 +1,208 @@
+// @bun
+import {
+  LOGGER_ERROR_KEYS
+} from "../../chunk-rz5p4j3p.js";
+import {
+  TypedEventEmitter
+} from "../../chunk-mvrxngm7.js";
+import {
+  BaseError
+} from "../../chunk-9cgzhc50.js";
+
+// source/modules/logger/logger.ts
+class Logger extends TypedEventEmitter {
+  _sinks;
+  _sinkKeys = [];
+  _worker;
+  _maxPendingLogs;
+  _maxMessagesInFlight;
+  _batchSize;
+  _batchTimeout;
+  _autoEnd;
+  _flushOnBeforeExit;
+  _pendingLogs = [];
+  _messagesInFlight = 0;
+  _batchTimer = null;
+  _isWriting = false;
+  _flushResolvers = [];
+  _closeResolver = null;
+  _backpressureResolver = null;
+  _handleExit = () => {
+    this._worker.terminate();
+  };
+  _handleWorkerClose = () => {
+    process.off("beforeExit", this._handleBeforeExit);
+    process.off("exit", this._handleExit);
+  };
+  constructor(options) {
+    super();
+    const {
+      autoEnd = true,
+      batchSize = 50,
+      batchTimeout = 0.1,
+      flushOnBeforeExit = true,
+      maxMessagesInFlight = 100,
+      maxPendingLogs = 1e4
+    } = options ?? {};
+    this._sinks = {};
+    this._maxPendingLogs = maxPendingLogs;
+    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();
+  }
+  registerSink(sinkName, sinkConstructor, ...sinkArgs) {
+    if (this._sinks[sinkName])
+      throw new BaseError(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, sinkNames = this._sinkKeys) {
+    this._enqueue("ERROR", object, sinkNames);
+  }
+  warn(object, sinkNames = this._sinkKeys) {
+    this._enqueue("WARN", object, sinkNames);
+  }
+  info(object, sinkNames = this._sinkKeys) {
+    this._enqueue("INFO", object, sinkNames);
+  }
+  debug(object, sinkNames = this._sinkKeys) {
+    this._enqueue("DEBUG", object, sinkNames);
+  }
+  log(object, sinkNames = this._sinkKeys) {
+    this._enqueue("LOG", object, sinkNames);
+  }
+  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();
+      }
+    });
+  }
+  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;
+    this._pendingLogs.push({
+      sinkNames: sinkNames ?? this._sinkKeys,
+      level,
+      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);
+    }
+  }
+  _triggerProcessing() {
+    if (this._isWriting)
+      return;
+    this._isWriting = true;
+    this._processPendingLogs();
+  }
+  async _processPendingLogs() {
+    while (this._pendingLogs.length > 0) {
+      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("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 }));
+      });
+    else
+      this.close().catch((error) => {
+        this.emit("onBeforeExitError", new BaseError(LOGGER_ERROR_KEYS.BEFORE_EXIT_CLOSE_ERROR, { error }));
+      });
+  };
+}
+export {
+  Logger
+};

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

@@ -1,4 +1,4 @@
-import { TypedEventEmitter } from '#/modules/typed-event-emitter/typed-event-emitter';
+import { TypedEventEmitter } from '../../modules/typed-event-emitter/typed-event-emitter';
 import type { LoggerEvent } from './events/logger-events';
 import type { LoggerOptions } from './types/logger-options';
 import type { LoggerSink } from './types/logger-sink';

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

@@ -1,5 +1,5 @@
-import type { LogLevels } from '#/modules/logger/types/log-levels';
-import type { LoggerSink } from '#/modules/logger/types/logger-sink';
+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.
 */

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

@@ -1,4 +1,4 @@
-import type { LoggerSink } from '#/modules/logger/types/logger-sink';
+import type { LoggerSink } from '../../../modules/logger/types/logger-sink';
 /**
  * DevNullLoggerSink implements LoggerSink to discard all logs (like /dev/null).
  * Useful for benchmarking the logger overhead without I/O.

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

@@ -1,5 +1,5 @@
-import type { LogLevels } from '#/modules/logger/types/log-levels';
-import type { LoggerSink } from '#/modules/logger/types/logger-sink';
+import type { LogLevels } from '../../../../modules/logger/types/log-levels';
+import type { LoggerSink } from '../../../../modules/logger/types/logger-sink';
 export interface FileLoggerConfig {
     /**
      * Path to the file to log to.