@mrxsys/mrx-core 2.11.0-1-and-273-20251029 → 2.11.0-1-and-276-20251029

package/dist/modules/elysia/cache/cache.d.ts

@@ -1,12 +1,9 @@
 import { Elysia } from 'elysia';
-import { MemoryStore } from '../../../modules/kv-store/memory/memory-store';
+import type { KvStore } from '../../../modules/kv-store/types/kv-store';
 import type { CacheOptions } from './types/cache-options';
-export declare const cache: ({ defaultTtl, prefix, store }?: CacheOptions) => Elysia<"", {
+export declare const cache: (store?: KvStore) => Elysia<"", {
     decorator: {};
-    store: {
-        kvStore: import("../../kv-store/types").KvStore | MemoryStore;
-        _cachedRoutes: Set<string>;
-    };
+    store: {};
     derive: {};
     resolve: {};
 }, {
@@ -16,11 +13,11 @@ export declare const cache: ({ defaultTtl, prefix, store }?: CacheOptions) => El
     schema: {};
     standaloneSchema: {};
     macro: Partial<{
-        readonly isCached: number | boolean;
+        readonly isCached: CacheOptions;
     }>;
     macroFn: {
-        readonly isCached: (enable: boolean | number) => {
-            readonly afterHandle: ({ set, responseValue, store, request }: {
+        readonly isCached: ({ ttl, prefix }: CacheOptions) => {
+            readonly afterHandle: ({ set, responseValue, request }: {
                 body: unknown;
                 query: Record<string, string>;
                 params: {};
@@ -37,10 +34,7 @@ export declare const cache: ({ defaultTtl, prefix, store }?: CacheOptions) => El
                 path: string;
                 route: string;
                 request: Request;
-                store: {
-                    kvStore: import("../../kv-store/types").KvStore | MemoryStore;
-                    _cachedRoutes: Set<string>;
-                };
+                store: {};
                 status: <const Code extends number | keyof import("elysia").StatusMap, const T = Code extends 100 | 101 | 102 | 103 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | 300 | 301 | 302 | 303 | 304 | 307 | 308 | 420 ? {
                     readonly 100: "Continue";
                     readonly 101: "Switching Protocols";

package/dist/modules/elysia/cache/index.js

@@ -3,68 +3,88 @@ import {
   MemoryStore
 } from "../../../chunk-e30paw8a.js";
 import"../../../chunk-xhhj1gvj.js";
-import {
-  generateCacheKey
-} from "../../../chunk-b23dvm2d.js";
 import"../../../chunk-9cgzhc50.js";
 
 // source/modules/elysia/cache/cache.ts
 import { Elysia } from "elysia";
-var cache = ({
-  defaultTtl = 60,
-  prefix = "",
-  store = ":memory:"
-} = {}) => new Elysia().state({
-  kvStore: store === ":memory:" ? new MemoryStore : store
-}).state({
-  _cachedRoutes: new Set
-}).onRequest(async ({ request, store: store2, set }) => {
-  const sanitizeUrl = new URL(request.url).pathname;
-  if (store2._cachedRoutes.has(`${request.method}:${sanitizeUrl}`)) {
-    const cacheKey = await generateCacheKey(request.clone());
-    const cachedData = await store2.kvStore.get(`${prefix}${cacheKey}`);
-    if (cachedData && typeof cachedData === "object" && "response" in cachedData && "metadata" in cachedData) {
-      const { response, metadata } = cachedData;
-      set.headers["cache-control"] = `max-age=${metadata.ttl}, public`;
-      set.headers["x-cache"] = "HIT";
-      set.headers["etag"] = `"${prefix}${cacheKey}"`;
-      set.headers["expires"] = new Date(Date.now() + metadata.ttl * 1000).toUTCString();
-      set.headers["last-modified"] = metadata.createdAt;
-      if (response instanceof Response)
-        return response.clone();
-      return response;
+
+// source/modules/elysia/cache/utils/generate-cache-key.ts
+var _calculateBodyHash = async (body, hasher) => {
+  if (!body)
+    return;
+  const reader = body.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (value)
+        hasher.update(new Uint8Array(value));
     }
-    set.headers["x-cache"] = "MISS";
+  } finally {
+    reader.releaseLock();
   }
-  return;
-}).macro({
-  isCached: (enable) => {
-    const ttl = typeof enable === "number" ? enable : enable ? defaultTtl : 0;
-    return {
-      async afterHandle({ set, responseValue, store: store2, request }) {
-        const sanitizeUrl = new URL(request.url).pathname;
-        if (!store2._cachedRoutes.has(`${request.method}:${sanitizeUrl}`))
-          store2._cachedRoutes.add(`${request.method}:${sanitizeUrl}`);
+};
+var generateCacheKey = async (request) => {
+  const { method, url, headers } = request;
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(method);
+  hasher.update(url);
+  hasher.update(JSON.stringify(headers));
+  await _calculateBodyHash(request.body, hasher);
+  return hasher.digest("hex");
+};
+
+// source/modules/elysia/cache/cache.ts
+var cache = (store = new MemoryStore) => {
+  const cachedRoutes = new Map;
+  return new Elysia().onRequest(async ({ request, set }) => {
+    const route = `${request.method}:${new URL(request.url).pathname}`;
+    if (cachedRoutes.has(route)) {
+      const { ttl, prefix } = cachedRoutes.get(route);
+      const cacheKey = await generateCacheKey(request.clone());
+      const cacheItem = await store.get(`${prefix}${cacheKey}`);
+      if (cacheItem && typeof cacheItem === "object" && "response" in cacheItem && "metadata" in cacheItem) {
+        const createdAt = new Date(cacheItem.metadata.createdAt);
+        const expiresAt = new Date(createdAt.getTime() + ttl * 1000);
+        const now = Date.now();
+        const remaining = Math.max(0, Math.ceil((expiresAt.getTime() - now) / 1000));
+        set.headers["cache-control"] = `max-age=${remaining}, public`;
+        set.headers["etag"] = `"${prefix}${cacheKey}"`;
+        set.headers["last-modified"] = cacheItem.metadata.createdAt;
+        set.headers["expires"] = expiresAt.toUTCString();
+        set.headers["x-cache"] = "HIT";
+        if (cacheItem.response instanceof Response)
+          return cacheItem.response.clone();
+        return cacheItem.response;
+      }
+      set.headers["x-cache"] = "MISS";
+    }
+    return;
+  }).macro({
+    isCached: ({ ttl, prefix = "" }) => ({
+      async afterHandle({ set, responseValue, request }) {
+        const route = `${request.method}:${new URL(request.url).pathname}`;
+        if (!cachedRoutes.has(route))
+          cachedRoutes.set(route, { ttl, prefix });
         const cacheKey = await generateCacheKey(request.clone());
         const now = new Date;
         set.headers["cache-control"] = `max-age=${ttl}, public`;
         set.headers["etag"] = `"${prefix}${cacheKey}"`;
         set.headers["last-modified"] = now.toUTCString();
         set.headers["expires"] = new Date(now.getTime() + ttl * 1000).toUTCString();
-        if (!set.headers["x-cache"])
-          set.headers["x-cache"] = "MISS";
-        const cacheData = {
+        set.headers["x-cache"] = "MISS";
+        const cacheItem = {
           response: responseValue instanceof Response ? responseValue.clone() : responseValue,
           metadata: {
-            createdAt: now.toUTCString(),
-            ttl
+            createdAt: now.toUTCString()
           }
         };
-        await store2.kvStore.set(`${prefix}${cacheKey}`, cacheData, ttl);
+        await store.set(`${prefix}${cacheKey}`, cacheItem, ttl);
       }
-    };
-  }
-});
+    })
+  });
+};
 export {
   cache
 };

package/dist/modules/elysia/cache/types/cache-item.d.ts

@@ -2,6 +2,5 @@ export interface CacheItem {
     response: unknown;
     metadata: {
         createdAt: string;
-        ttl: number;
     };
 }

package/dist/modules/elysia/cache/types/cache-options.d.ts

@@ -1,21 +1,12 @@
-import type { KvStore } from '../../../../modules/kv-store/types/kv-store';
 export interface CacheOptions {
     /**
-     * Default TTL in seconds
-     *
-     * @defaultValue 60
+     * TTL in seconds
      */
-    defaultTtl?: number;
+    ttl: number;
     /**
      * Cache key prefix
      *
      * @defaultValue ''
      */
     prefix?: string;
-    /**
-     * Storage backend
-     *
-     * @defaultValue ':memory:'
-     */
-    store?: ':memory:' | KvStore;
 }

package/dist/modules/elysia/crud/index.js

@@ -1,14 +1,4 @@
 // @bun
-import {
-  batchDelete,
-  count,
-  deleteOne,
-  find,
-  findOne,
-  insert,
-  update,
-  updateOne
-} from "../../../chunk-pjv1ekwr.js";
 import {
   createCountResponse200Schema,
   createCountSchema,
@@ -21,6 +11,16 @@ import {
   createUpdateSchema
 } from "../../../chunk-p14h6jfs.js";
 import"../../../chunk-9dzsj7f2.js";
+import {
+  batchDelete,
+  count,
+  deleteOne,
+  find,
+  findOne,
+  insert,
+  update,
+  updateOne
+} from "../../../chunk-pjv1ekwr.js";
 import"../../../chunk-441xs5k1.js";
 import"../../../chunk-fs3wm3p4.js";
 import"../../../chunk-z0ct35ft.js";

package/dist/modules/elysia/error/error.d.ts

@@ -21,21 +21,7 @@ export declare const error: Elysia<"", {
     macro: {};
     macroFn: {};
     parser: {};
-    response: {
-        200: {
-            message: string;
-            content: any;
-        } | {
-            message: "mrx-core.error.not_found";
-            content?: never;
-        } | {
-            message: "mrx-core.error.parse";
-            content?: never;
-        } | {
-            message: "mrx-core.error.internal_server_error";
-            content?: never;
-        };
-    };
+    response: {};
 }, {}, {
     derive: {};
     resolve: {};

package/dist/modules/elysia/error/index.js

@@ -21,54 +21,51 @@ var error = new Elysia({
 }).error({
   BaseError,
   HttpError
-}).onError(({ code, error: error2, set }) => {
+}).onError(({ code, error: error2, set, status }) => {
   set.headers["content-type"] = "application/json; charset=utf-8";
   switch (code) {
     case "HttpError":
-      set.status = error2.httpStatusCode;
-      return {
+      status(error2.httpStatusCode, {
         message: error2.message,
         content: error2.cause
-      };
+      });
+      break;
     case "BaseError":
-      set.status = 500;
-      return {
-        message: error2.message,
+      status(500, {
+        message: ERROR_KEYS.CORE_ERROR_INTERNAL_SERVER_ERROR,
         content: error2.cause
-      };
+      });
+      break;
     case "VALIDATION": {
-      set.status = 422;
-      return {
-        message: ERROR_KEYS.CORE_ERROR_VALIDATION,
-        content: {
-          on: error2.type,
-          errors: error2.all.map((e) => ({
-            path: e.path,
-            value: e.value,
-            summary: e.summary,
-            message: e.schema?.error,
-            schema: filterByKeyExclusion(e.schema, ["error"], true)
-          }))
-        }
-      };
+      status(422, {
+        on: error2.type,
+        errors: error2.all.map((e) => ({
+          path: e.path,
+          value: e.value,
+          summary: e.summary,
+          message: e.schema?.error,
+          schema: filterByKeyExclusion(e.schema, ["error"], true)
+        }))
+      });
+      break;
     }
     case "NOT_FOUND":
-      set.status = 404;
-      return {
+      status(404, {
         message: ERROR_KEYS.CORE_ERROR_NOT_FOUND
-      };
+      });
+      break;
     case "PARSE":
-      set.status = 400;
-      return {
+      status(400, {
         message: ERROR_KEYS.CORE_ERROR_PARSE
-      };
+      });
+      break;
     case "INTERNAL_SERVER_ERROR":
     case "UNKNOWN":
     default:
-      set.status = 500;
-      return {
+      status(500, {
         message: ERROR_KEYS.CORE_ERROR_INTERNAL_SERVER_ERROR
-      };
+      });
+      break;
   }
 }).as("global");
 export {

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

@@ -14,40 +14,66 @@ import"../../../chunk-9cgzhc50.js";
 
 // source/modules/elysia/rate-limit/rate-limit.ts
 import { Elysia } from "elysia";
-var rateLimit = ({ store, limit, window }) => {
-  const storeInstance = store === ":memory:" || !store ? new MemoryStore : store;
-  return new Elysia({
-    name: "rateLimit",
-    seed: {
-      store,
-      limit,
-      window
-    }
-  }).onRequest(async ({ set, request, server }) => {
-    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:${ip}`;
-    const count = await storeInstance.get(key);
-    let newCount;
-    if (count === null) {
-      await storeInstance.set(key, 1, window);
-      newCount = 1;
+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 {
-      newCount = await storeInstance.increment(key);
+      count = await store.increment(key);
     }
-    if (newCount > limit) {
+    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: await storeInstance.ttl(key)
+        reset: resetTime
       });
     }
-    set.headers = {
-      "X-RateLimit-Limit": limit.toString(),
-      "X-RateLimit-Remaining": Math.max(0, limit - newCount).toString(),
-      "X-RateLimit-Reset": (await storeInstance.ttl(key)).toString()
-    };
+  };
+  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 {

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

@@ -1,42 +1,55 @@
-import { Elysia } from 'elysia';
+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';
 /**
- * The `rateLimitPlugin` provides rate limiting capabilities for Elysia applications,
- * protecting APIs from excessive use and potential abuse. It tracks request rates by client IP
- * and enforces configurable limits based on a sliding time window.
+ * Rate limiting plugin for Elysia applications that protects APIs from excessive use and potential abuse.
  *
- * ### Rate Limit Headers:
- * The plugin adds the following headers to all responses:
+ * The plugin tracks request rates by client IP address and enforces configurable limits based on a fixed time window.
+ * It supports multiple storage backends through the `@mrxsys/mrx-core/modules/kv-store` ecosystem for both single-instance and distributed deployments.
+ *
+ * ### How It Works
+ * - Rate limiting is applied per IP address and per route
+ * - Each route can have its own limit and time window configuration
+ * - Route-level rate limits override global rate limits
+ * - Headers are added to all responses indicating the current rate limit status
+ *
+ * ### Rate Limit Headers
+ * The plugin adds the following headers to all responses (including 429 errors):
  * - `X-RateLimit-Limit`: The maximum number of requests allowed in the window
  * - `X-RateLimit-Remaining`: The number of requests remaining in the current window
- * - `X-RateLimit-Reset`: The time in seconds until the rate limit resets
+ * - `X-RateLimit-Reset`: The time in seconds until the rate limit resets (Unix timestamp)
+ *
+ * When a rate limit is exceeded, the response includes a 429 (Too Many Requests) status code
+ * and the error key `elysia.rate-limit.error.exceeded`, along with the rate limit headers
+ * to help clients implement exponential backoff retry strategies.
  *
- * @param options - The configuration options for the rate limit plugin
+ * @param store - The KV store instance for tracking rate limits. Defaults to an in-memory store.
+ * Supports any `KvStore` implementation from `@mrxsys/mrx-core/modules/kv-store` (e.g., `MemoryStore`, `IoRedisStore`)
  *
- * @returns An {@link Elysia} plugin that adds rate limiting functionality
+ * @returns An {@link Elysia} plugin that adds rate limiting functionality via the `rateLimit` macro
  *
  * @example
- * Basic usage with default in-memory store
+ * Basic usage with default in-memory store (development)
  * ```ts
- * import { rateLimit } from '@nowarajs/elysia-ratelimit';
+ * import { rateLimit } from '@mrxsys/mrx-core/modules/elysia/elysia-ratelimit';
  * import { Elysia } from 'elysia';
  *
  * const app = new Elysia()
- *   .use(rateLimit({
- *     store: ':memory:',    // Use in-memory store
- *     limit: 100,           // 100 requests
- *     window: 60,           // per minute
- *   }))
- *   .get('/api/endpoint', () => ({ message: 'Hello World' }));
- *
- * app.listen(3000);
+ *   .use(rateLimit())
+ *   .get('/api/data', () => ({ message: 'Hello World' }), {
+ *     rateLimit: {
+ *       limit: 100,         // 100 requests
+ *       window: 60          // per minute
+ *     }
+ *   })
+ *   .listen(3000);
  * ```
  *
  * @example
- * Using Redis store for distributed rate limiting
+ * Using Redis store for distributed rate limiting (production)
  * ```ts
- * import { IoRedisStore } from '@nowarajs/kv-store';
- * import { rateLimit } from '@nowarajs/elysia-ratelimit';
+ * import { IoRedisStore } from '@mrxsys/mrx-core/modules/kv-store/ioredis'; // or use bun-redis
+ * import { rateLimit } from '@mrxsys/mrx-core/modules/elysia/elysia-ratelimit';
  * import { Elysia } from 'elysia';
  *
  * const redisStore = new IoRedisStore({
@@ -46,17 +59,40 @@ import type { RateLimitOptions } from './types/rate-limit-options';
  * await redisStore.connect();
  *
  * const app = new Elysia()
- *   .use(rateLimit({
- *     store: redisStore,
- *     limit: 1000,          // 1000 requests
- *     window: 3600,         // per hour
- *   }))
- *   .get('/api/endpoint', () => ({ message: 'Hello World' }));
+ *   .use(rateLimit(redisStore))
+ *   .get('/api/endpoint', () => ({ data: 'content' }), {
+ *     rateLimit: {
+ *       limit: 1000,        // 1000 requests
+ *       window: 3600        // per hour
+ *     }
+ *   })
+ *   .listen(3000);
+ * ```
  *
- * app.listen(3000);
+ * @example
+ * Global rate limit with route-level overrides
+ * ```ts
+ * const app = new Elysia()
+ *   .use(rateLimit())
+ *   .guard({
+ *     rateLimit: {
+ *       limit: 100,
+ *       window: 60
+ *     }
+ *   })
+ *   .get('/api/slow', () => 'content', {
+ *     rateLimit: {
+ *       limit: 10,          // Override global: stricter limit
+ *       window: 60
+ *     }
+ *   })
+ *   .get('/api/fast', () => 'content')  // Uses global limit
+ *   .listen(3000);
  * ```
+ *
+ * @throws ({@link HttpError}) – `elysia.rate-limit.error.exceeded` when the rate limit is exceeded (HTTP 429)
  */
-export declare const rateLimit: ({ store, limit, window }: RateLimitOptions) => Elysia<"", {
+export declare const rateLimit: (store?: KvStore) => Elysia<"", {
     decorator: {};
     store: {};
     derive: {};
@@ -67,8 +103,301 @@ export declare const rateLimit: ({ store, limit, window }: RateLimitOptions) =>
 }, {
     schema: {};
     standaloneSchema: {};
-    macro: {};
-    macroFn: {};
+    macro: Partial<{
+        readonly rateLimit: RateLimitOptions;
+    }>;
+    macroFn: {
+        readonly rateLimit: ({ limit, window }: RateLimitOptions) => {
+            readonly transform: ({ request }: {
+                body: unknown;
+                query: Record<string, string>;
+                params: {};
+                headers: Record<string, string | undefined>;
+                cookie: Record<string, import("elysia").Cookie<unknown>>;
+                server: import("elysia/universal/server").Server | null;
+                redirect: import("elysia").redirect;
+                set: {
+                    headers: HTTPHeaders;
+                    status?: number | keyof StatusMap;
+                    redirect?: string;
+                    cookie?: Record<string, import("elysia/cookies").ElysiaCookie>;
+                };
+                path: string;
+                route: string;
+                request: Request;
+                store: {};
+                status: <const Code extends number | keyof StatusMap, const T = Code extends 100 | 101 | 102 | 103 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | 300 | 301 | 302 | 303 | 304 | 307 | 308 | 420 ? {
+                    readonly 100: "Continue";
+                    readonly 101: "Switching Protocols";
+                    readonly 102: "Processing";
+                    readonly 103: "Early Hints";
+                    readonly 200: "OK";
+                    readonly 201: "Created";
+                    readonly 202: "Accepted";
+                    readonly 203: "Non-Authoritative Information";
+                    readonly 204: "No Content";
+                    readonly 205: "Reset Content";
+                    readonly 206: "Partial Content";
+                    readonly 207: "Multi-Status";
+                    readonly 208: "Already Reported";
+                    readonly 300: "Multiple Choices";
+                    readonly 301: "Moved Permanently";
+                    readonly 302: "Found";
+                    readonly 303: "See Other";
+                    readonly 304: "Not Modified";
+                    readonly 307: "Temporary Redirect";
+                    readonly 308: "Permanent Redirect";
+                    readonly 400: "Bad Request";
+                    readonly 401: "Unauthorized";
+                    readonly 402: "Payment Required";
+                    readonly 403: "Forbidden";
+                    readonly 404: "Not Found";
+                    readonly 405: "Method Not Allowed";
+                    readonly 406: "Not Acceptable";
+                    readonly 407: "Proxy Authentication Required";
+                    readonly 408: "Request Timeout";
+                    readonly 409: "Conflict";
+                    readonly 410: "Gone";
+                    readonly 411: "Length Required";
+                    readonly 412: "Precondition Failed";
+                    readonly 413: "Payload Too Large";
+                    readonly 414: "URI Too Long";
+                    readonly 415: "Unsupported Media Type";
+                    readonly 416: "Range Not Satisfiable";
+                    readonly 417: "Expectation Failed";
+                    readonly 418: "I'm a teapot";
+                    readonly 420: "Enhance Your Calm";
+                    readonly 421: "Misdirected Request";
+                    readonly 422: "Unprocessable Content";
+                    readonly 423: "Locked";
+                    readonly 424: "Failed Dependency";
+                    readonly 425: "Too Early";
+                    readonly 426: "Upgrade Required";
+                    readonly 428: "Precondition Required";
+                    readonly 429: "Too Many Requests";
+                    readonly 431: "Request Header Fields Too Large";
+                    readonly 451: "Unavailable For Legal Reasons";
+                    readonly 500: "Internal Server Error";
+                    readonly 501: "Not Implemented";
+                    readonly 502: "Bad Gateway";
+                    readonly 503: "Service Unavailable";
+                    readonly 504: "Gateway Timeout";
+                    readonly 505: "HTTP Version Not Supported";
+                    readonly 506: "Variant Also Negotiates";
+                    readonly 507: "Insufficient Storage";
+                    readonly 508: "Loop Detected";
+                    readonly 510: "Not Extended";
+                    readonly 511: "Network Authentication Required";
+                }[Code] : Code>(code: Code, response?: T) => import("elysia").ElysiaCustomStatusResponse<Code, T, Code extends "Continue" | "Switching Protocols" | "Processing" | "Early Hints" | "OK" | "Created" | "Accepted" | "Non-Authoritative Information" | "No Content" | "Reset Content" | "Partial Content" | "Multi-Status" | "Already Reported" | "Multiple Choices" | "Moved Permanently" | "Found" | "See Other" | "Not Modified" | "Temporary Redirect" | "Permanent Redirect" | "Bad Request" | "Unauthorized" | "Payment Required" | "Forbidden" | "Not Found" | "Method Not Allowed" | "Not Acceptable" | "Proxy Authentication Required" | "Request Timeout" | "Conflict" | "Gone" | "Length Required" | "Precondition Failed" | "Payload Too Large" | "URI Too Long" | "Unsupported Media Type" | "Range Not Satisfiable" | "Expectation Failed" | "I'm a teapot" | "Enhance Your Calm" | "Misdirected Request" | "Unprocessable Content" | "Locked" | "Failed Dependency" | "Too Early" | "Upgrade Required" | "Precondition Required" | "Too Many Requests" | "Request Header Fields Too Large" | "Unavailable For Legal Reasons" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "HTTP Version Not Supported" | "Variant Also Negotiates" | "Insufficient Storage" | "Loop Detected" | "Not Extended" | "Network Authentication Required" ? {
+                    readonly Continue: 100;
+                    readonly "Switching Protocols": 101;
+                    readonly Processing: 102;
+                    readonly "Early Hints": 103;
+                    readonly OK: 200;
+                    readonly Created: 201;
+                    readonly Accepted: 202;
+                    readonly "Non-Authoritative Information": 203;
+                    readonly "No Content": 204;
+                    readonly "Reset Content": 205;
+                    readonly "Partial Content": 206;
+                    readonly "Multi-Status": 207;
+                    readonly "Already Reported": 208;
+                    readonly "Multiple Choices": 300;
+                    readonly "Moved Permanently": 301;
+                    readonly Found: 302;
+                    readonly "See Other": 303;
+                    readonly "Not Modified": 304;
+                    readonly "Temporary Redirect": 307;
+                    readonly "Permanent Redirect": 308;
+                    readonly "Bad Request": 400;
+                    readonly Unauthorized: 401;
+                    readonly "Payment Required": 402;
+                    readonly Forbidden: 403;
+                    readonly "Not Found": 404;
+                    readonly "Method Not Allowed": 405;
+                    readonly "Not Acceptable": 406;
+                    readonly "Proxy Authentication Required": 407;
+                    readonly "Request Timeout": 408;
+                    readonly Conflict: 409;
+                    readonly Gone: 410;
+                    readonly "Length Required": 411;
+                    readonly "Precondition Failed": 412;
+                    readonly "Payload Too Large": 413;
+                    readonly "URI Too Long": 414;
+                    readonly "Unsupported Media Type": 415;
+                    readonly "Range Not Satisfiable": 416;
+                    readonly "Expectation Failed": 417;
+                    readonly "I'm a teapot": 418;
+                    readonly "Enhance Your Calm": 420;
+                    readonly "Misdirected Request": 421;
+                    readonly "Unprocessable Content": 422;
+                    readonly Locked: 423;
+                    readonly "Failed Dependency": 424;
+                    readonly "Too Early": 425;
+                    readonly "Upgrade Required": 426;
+                    readonly "Precondition Required": 428;
+                    readonly "Too Many Requests": 429;
+                    readonly "Request Header Fields Too Large": 431;
+                    readonly "Unavailable For Legal Reasons": 451;
+                    readonly "Internal Server Error": 500;
+                    readonly "Not Implemented": 501;
+                    readonly "Bad Gateway": 502;
+                    readonly "Service Unavailable": 503;
+                    readonly "Gateway Timeout": 504;
+                    readonly "HTTP Version Not Supported": 505;
+                    readonly "Variant Also Negotiates": 506;
+                    readonly "Insufficient Storage": 507;
+                    readonly "Loop Detected": 508;
+                    readonly "Not Extended": 510;
+                    readonly "Network Authentication Required": 511;
+                }[Code] : Code>;
+            }) => void;
+            readonly beforeHandle: ({ set, request, server }: {
+                body: unknown;
+                query: Record<string, string>;
+                params: {};
+                headers: Record<string, string | undefined>;
+                cookie: Record<string, import("elysia").Cookie<unknown>>;
+                server: import("elysia/universal/server").Server | null;
+                redirect: import("elysia").redirect;
+                set: {
+                    headers: HTTPHeaders;
+                    status?: number | keyof StatusMap;
+                    redirect?: string;
+                    cookie?: Record<string, import("elysia/cookies").ElysiaCookie>;
+                };
+                path: string;
+                route: string;
+                request: Request;
+                store: {};
+                status: <const Code extends number | keyof StatusMap, const T = Code extends 100 | 101 | 102 | 103 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | 300 | 301 | 302 | 303 | 304 | 307 | 308 | 420 ? {
+                    readonly 100: "Continue";
+                    readonly 101: "Switching Protocols";
+                    readonly 102: "Processing";
+                    readonly 103: "Early Hints";
+                    readonly 200: "OK";
+                    readonly 201: "Created";
+                    readonly 202: "Accepted";
+                    readonly 203: "Non-Authoritative Information";
+                    readonly 204: "No Content";
+                    readonly 205: "Reset Content";
+                    readonly 206: "Partial Content";
+                    readonly 207: "Multi-Status";
+                    readonly 208: "Already Reported";
+                    readonly 300: "Multiple Choices";
+                    readonly 301: "Moved Permanently";
+                    readonly 302: "Found";
+                    readonly 303: "See Other";
+                    readonly 304: "Not Modified";
+                    readonly 307: "Temporary Redirect";
+                    readonly 308: "Permanent Redirect";
+                    readonly 400: "Bad Request";
+                    readonly 401: "Unauthorized";
+                    readonly 402: "Payment Required";
+                    readonly 403: "Forbidden";
+                    readonly 404: "Not Found";
+                    readonly 405: "Method Not Allowed";
+                    readonly 406: "Not Acceptable";
+                    readonly 407: "Proxy Authentication Required";
+                    readonly 408: "Request Timeout";
+                    readonly 409: "Conflict";
+                    readonly 410: "Gone";
+                    readonly 411: "Length Required";
+                    readonly 412: "Precondition Failed";
+                    readonly 413: "Payload Too Large";
+                    readonly 414: "URI Too Long";
+                    readonly 415: "Unsupported Media Type";
+                    readonly 416: "Range Not Satisfiable";
+                    readonly 417: "Expectation Failed";
+                    readonly 418: "I'm a teapot";
+                    readonly 420: "Enhance Your Calm";
+                    readonly 421: "Misdirected Request";
+                    readonly 422: "Unprocessable Content";
+                    readonly 423: "Locked";
+                    readonly 424: "Failed Dependency";
+                    readonly 425: "Too Early";
+                    readonly 426: "Upgrade Required";
+                    readonly 428: "Precondition Required";
+                    readonly 429: "Too Many Requests";
+                    readonly 431: "Request Header Fields Too Large";
+                    readonly 451: "Unavailable For Legal Reasons";
+                    readonly 500: "Internal Server Error";
+                    readonly 501: "Not Implemented";
+                    readonly 502: "Bad Gateway";
+                    readonly 503: "Service Unavailable";
+                    readonly 504: "Gateway Timeout";
+                    readonly 505: "HTTP Version Not Supported";
+                    readonly 506: "Variant Also Negotiates";
+                    readonly 507: "Insufficient Storage";
+                    readonly 508: "Loop Detected";
+                    readonly 510: "Not Extended";
+                    readonly 511: "Network Authentication Required";
+                }[Code] : Code>(code: Code, response?: T) => import("elysia").ElysiaCustomStatusResponse<Code, T, Code extends "Continue" | "Switching Protocols" | "Processing" | "Early Hints" | "OK" | "Created" | "Accepted" | "Non-Authoritative Information" | "No Content" | "Reset Content" | "Partial Content" | "Multi-Status" | "Already Reported" | "Multiple Choices" | "Moved Permanently" | "Found" | "See Other" | "Not Modified" | "Temporary Redirect" | "Permanent Redirect" | "Bad Request" | "Unauthorized" | "Payment Required" | "Forbidden" | "Not Found" | "Method Not Allowed" | "Not Acceptable" | "Proxy Authentication Required" | "Request Timeout" | "Conflict" | "Gone" | "Length Required" | "Precondition Failed" | "Payload Too Large" | "URI Too Long" | "Unsupported Media Type" | "Range Not Satisfiable" | "Expectation Failed" | "I'm a teapot" | "Enhance Your Calm" | "Misdirected Request" | "Unprocessable Content" | "Locked" | "Failed Dependency" | "Too Early" | "Upgrade Required" | "Precondition Required" | "Too Many Requests" | "Request Header Fields Too Large" | "Unavailable For Legal Reasons" | "Internal Server Error" | "Not Implemented" | "Bad Gateway" | "Service Unavailable" | "Gateway Timeout" | "HTTP Version Not Supported" | "Variant Also Negotiates" | "Insufficient Storage" | "Loop Detected" | "Not Extended" | "Network Authentication Required" ? {
+                    readonly Continue: 100;
+                    readonly "Switching Protocols": 101;
+                    readonly Processing: 102;
+                    readonly "Early Hints": 103;
+                    readonly OK: 200;
+                    readonly Created: 201;
+                    readonly Accepted: 202;
+                    readonly "Non-Authoritative Information": 203;
+                    readonly "No Content": 204;
+                    readonly "Reset Content": 205;
+                    readonly "Partial Content": 206;
+                    readonly "Multi-Status": 207;
+                    readonly "Already Reported": 208;
+                    readonly "Multiple Choices": 300;
+                    readonly "Moved Permanently": 301;
+                    readonly Found: 302;
+                    readonly "See Other": 303;
+                    readonly "Not Modified": 304;
+                    readonly "Temporary Redirect": 307;
+                    readonly "Permanent Redirect": 308;
+                    readonly "Bad Request": 400;
+                    readonly Unauthorized: 401;
+                    readonly "Payment Required": 402;
+                    readonly Forbidden: 403;
+                    readonly "Not Found": 404;
+                    readonly "Method Not Allowed": 405;
+                    readonly "Not Acceptable": 406;
+                    readonly "Proxy Authentication Required": 407;
+                    readonly "Request Timeout": 408;
+                    readonly Conflict: 409;
+                    readonly Gone: 410;
+                    readonly "Length Required": 411;
+                    readonly "Precondition Failed": 412;
+                    readonly "Payload Too Large": 413;
+                    readonly "URI Too Long": 414;
+                    readonly "Unsupported Media Type": 415;
+                    readonly "Range Not Satisfiable": 416;
+                    readonly "Expectation Failed": 417;
+                    readonly "I'm a teapot": 418;
+                    readonly "Enhance Your Calm": 420;
+                    readonly "Misdirected Request": 421;
+                    readonly "Unprocessable Content": 422;
+                    readonly Locked: 423;
+                    readonly "Failed Dependency": 424;
+                    readonly "Too Early": 425;
+                    readonly "Upgrade Required": 426;
+                    readonly "Precondition Required": 428;
+                    readonly "Too Many Requests": 429;
+                    readonly "Request Header Fields Too Large": 431;
+                    readonly "Unavailable For Legal Reasons": 451;
+                    readonly "Internal Server Error": 500;
+                    readonly "Not Implemented": 501;
+                    readonly "Bad Gateway": 502;
+                    readonly "Service Unavailable": 503;
+                    readonly "Gateway Timeout": 504;
+                    readonly "HTTP Version Not Supported": 505;
+                    readonly "Variant Also Negotiates": 506;
+                    readonly "Insufficient Storage": 507;
+                    readonly "Loop Detected": 508;
+                    readonly "Not Extended": 510;
+                    readonly "Network Authentication Required": 511;
+                }[Code] : Code>;
+            }) => Promise<void>;
+        };
+    };
     parser: {};
     response: {};
 }, {}, {

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

@@ -1,13 +1,4 @@
-import type { KvStore } from '../../../../modules/kv-store/types/kv-store';
 export interface RateLimitOptions {
-    /**
-     * Storage backend for rate limit data.
-     *
-     * - If not specified, defaults to in-memory storage
-     * - Use ':memory:' to explicitly specify in-memory storage
-     * - Provide a KvStore instance for persistent distributed storage
-     */
-    readonly store?: ':memory:' | KvStore;
     /**
      * Maximum number of requests allowed in the time window.
      *

package/package.json

@@ -1,26 +1,26 @@
 {
 	"name": "@mrxsys/mrx-core",
-	"version": "2.11.0-1-and-273-20251029",
+	"version": "2.11.0-1-and-276-20251029",
 	"author": "Ruby",
 	"devDependencies": {
 		"@eslint/js": "^9.38.0",
 		"@sinclair/typebox": "0.34.41",
 		"@stylistic/eslint-plugin": "^5.5.0",
-		"@types/bun": "^1.3.0",
-		"@types/nodemailer": "^7.0.2",
-		"elysia": "1.4.12",
+		"@types/bun": "^1.3.1",
+		"@types/nodemailer": "^7.0.3",
+		"elysia": "1.4.13",
 		"eslint": "^9.38.0",
 		"globals": "^16.4.0",
 		"ioredis": "^5.8.2",
 		"jose": "^6.1.0",
 		"knex": "^3.1.0",
 		"mssql": "^12.0.0",
-		"nodemailer": "^7.0.9",
+		"nodemailer": "^7.0.10",
 		"typescript-eslint": "^8.46.2"
 	},
 	"peerDependencies": {
 		"@sinclair/typebox": "0.34.41",
-		"elysia": "^1.4.12",
+		"elysia": "^1.4.13",
 		"ioredis": "^5.8.2",
 		"jose": "^6.1.0",
 		"mssql": "^12.0.0",
@@ -42,7 +42,6 @@
 		"./modules/database/types": "./dist/modules/database/types/index.js",
 		"./modules/elysia/cache": "./dist/modules/elysia/cache/index.js",
 		"./modules/elysia/cache/types": "./dist/modules/elysia/cache/types/index.js",
-		"./modules/elysia/cache/utils": "./dist/modules/elysia/cache/utils/index.js",
 		"./modules/elysia/crud": "./dist/modules/elysia/crud/index.js",
 		"./modules/elysia/crud/enums": "./dist/modules/elysia/crud/enums/index.js",
 		"./modules/elysia/crud/operations": "./dist/modules/elysia/crud/operations/index.js",
@@ -180,9 +179,9 @@
 		"fix-lint": "eslint --fix ./source",
 		"lint": "eslint ./source",
 		"start": "bun build/index.js",
-		"test:integration": "bun test --timeout 6000 $(find test/integration -name '*.spec.ts')",
-		"test:unit": "bun test --timeout 6000 --coverage $(find test/unit -name '*.spec.ts')",
-		"test": "bun test --coverage --timeout 6000"
+		"test:integration": "bun test --timeout 10000 $(find test/integration -name '*.spec.ts')",
+		"test:unit": "bun test --timeout 10000 --coverage $(find test/unit -name '*.spec.ts')",
+		"test": "bun test --coverage --timeout 10000"
 	},
 	"type": "module"
 }

package/dist/chunk-b23dvm2d.js

@@ -1,29 +0,0 @@
-// @bun
-// source/modules/elysia/cache/utils/generate-cache-key.ts
-var _calculateBodyHash = async (body, hasher) => {
-  if (!body)
-    return;
-  const reader = body.getReader();
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      if (value)
-        hasher.update(new Uint8Array(value));
-    }
-  } finally {
-    reader.releaseLock();
-  }
-};
-var generateCacheKey = async (request) => {
-  const { method, url, headers } = request;
-  const hasher = new Bun.CryptoHasher("sha256");
-  hasher.update(method);
-  hasher.update(url);
-  hasher.update(JSON.stringify(headers));
-  await _calculateBodyHash(request.body, hasher);
-  return hasher.digest("hex");
-};
-
-export { generateCacheKey };

package/dist/modules/elysia/cache/utils/index.d.ts

@@ -1 +0,0 @@
-export { generateCacheKey } from './generate-cache-key';

package/dist/modules/elysia/cache/utils/index.js

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