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

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

@@ -33,6 +33,7 @@ export declare const microservice: Elysia<"/microservice", {
     macro: {};
     macroFn: {};
     parser: {};
+    response: {};
 }, {
     microservice: {
         ping: {
@@ -42,9 +43,6 @@ export declare const microservice: Elysia<"/microservice", {
                 query: unknown;
                 headers: unknown;
                 response: {
-                    200: {
-                        message: string;
-                    };
                     422: {
                         type: "validation";
                         on: string;
@@ -54,6 +52,9 @@ export declare const microservice: Elysia<"/microservice", {
                         property?: string;
                         expected?: string;
                     };
+                    200: {
+                        message: string;
+                    };
                 };
             };
         };
@@ -67,15 +68,6 @@ export declare const microservice: Elysia<"/microservice", {
                 query: unknown;
                 headers: unknown;
                 response: {
-                    200: {
-                        message: string;
-                        content: {
-                            description: string;
-                            version: string;
-                            name: string;
-                            author: string;
-                        };
-                    };
                     422: {
                         type: "validation";
                         on: string;
@@ -85,6 +77,15 @@ export declare const microservice: Elysia<"/microservice", {
                         property?: string;
                         expected?: string;
                     };
+                    200: {
+                        message: string;
+                        content: {
+                            description: string;
+                            version: string;
+                            name: string;
+                            author: string;
+                        };
+                    };
                 };
             };
         };
@@ -92,11 +93,13 @@ export declare const microservice: Elysia<"/microservice", {
 }, {
     derive: {};
     resolve: {};
-    schema: import("elysia").MergeSchema<{}, {}, "">;
-    standaloneSchema: import("elysia/types").PrettifySchema<{}>;
+    schema: {};
+    standaloneSchema: {};
+    response: {};
 }, {
     derive: {};
     resolve: {};
     schema: {};
     standaloneSchema: {};
+    response: {};
 }>;

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

@@ -0,0 +1 @@
+export { RATE_LIMIT_ERROR_KEYS } from './rate-limit-error-keys';

package/dist/modules/elysia/{rateLimit → rate-limit}/enums/index.js

@@ -1,7 +1,7 @@
 // @bun
 import {
   RATE_LIMIT_ERROR_KEYS
-} from "../../../../chunk-yd82hdxv.js";
+} from "../../../../chunk-w1547qd4.js";
 export {
   RATE_LIMIT_ERROR_KEYS
 };

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

@@ -0,0 +1 @@
+export { rateLimit } from './rate-limit';

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

@@ -0,0 +1,55 @@
+// @bun
+import {
+  RATE_LIMIT_ERROR_KEYS
+} from "../../../chunk-w1547qd4.js";
+import {
+  MemoryStore
+} from "../../../chunk-k9dtqf1p.js";
+import"../../../chunk-6tqh339a.js";
+import {
+  HttpError
+} from "../../../chunk-00s6t4tw.js";
+import"../../../chunk-h9t48r9q.js";
+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;
+    } else {
+      newCount = await storeInstance.increment(key);
+    }
+    if (newCount > 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)
+      });
+    }
+    set.headers = {
+      "X-RateLimit-Limit": limit.toString(),
+      "X-RateLimit-Remaining": Math.max(0, limit - newCount).toString(),
+      "X-RateLimit-Reset": (await storeInstance.ttl(key)).toString()
+    };
+  }).as("global");
+};
+export {
+  rateLimit
+};

package/dist/modules/elysia/{rateLimit/rateLimit.d.ts → rate-limit/rate-limit.d.ts}

@@ -1,5 +1,5 @@
 import { Elysia } from 'elysia';
-import type { RateLimitOptions } from './types/rateLimitOptions';
+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
@@ -16,26 +16,43 @@ import type { RateLimitOptions } from './types/rateLimitOptions';
  * @returns An {@link Elysia} plugin that adds rate limiting functionality
  *
  * @example
+ * Basic usage with default in-memory store
  * ```ts
- * // Create Redis instance
- * const redis = new Redis({
+ * import { rateLimit } from '@nowarajs/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);
+ * ```
+ *
+ * @example
+ * Using Redis store for distributed rate limiting
+ * ```ts
+ * import { IoRedisStore } from '@nowarajs/kv-store';
+ * import { rateLimit } from '@nowarajs/elysia-ratelimit';
+ * import { Elysia } from 'elysia';
+ *
+ * const redisStore = new IoRedisStore({
  *   host: 'localhost',
  *   port: 6379
  * });
- * await redis.connect();
+ * await redisStore.connect();
  *
- * // Create and configure the application with rate limiting
  * const app = new Elysia()
  *   .use(rateLimit({
- *     store: redis,
- *     limit: 100,           // 100 requests
- *     window: 60,           // per minute
+ *     store: redisStore,
+ *     limit: 1000,          // 1000 requests
+ *     window: 3600,         // per hour
  *   }))
- *   .get('/public-api', () => {
- *     return { success: true, message: 'This endpoint is rate limited' };
- *   });
+ *   .get('/api/endpoint', () => ({ message: 'Hello World' }));
  *
- * // Start the server
  * app.listen(3000);
  * ```
  */
@@ -48,19 +65,22 @@ export declare const rateLimit: ({ store, limit, window }: RateLimitOptions) =>
     typebox: {};
     error: {};
 }, {
-    schema: import("elysia").MergeSchema<import("elysia").MergeSchema<{}, {}, "">, {}, "">;
+    schema: {};
     standaloneSchema: {};
     macro: {};
     macroFn: {};
     parser: {};
+    response: {};
 }, {}, {
     derive: {};
     resolve: {};
     schema: {};
     standaloneSchema: {};
+    response: {};
 }, {
     derive: {};
     resolve: {};
     schema: {};
     standaloneSchema: {};
+    response: {};
 }>;

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

@@ -0,0 +1 @@
+export type { RateLimitOptions } from './rate-limit-options';

package/dist/modules/elysia/{rateLimit/types/rateLimitOptions.d.ts → rate-limit/types/rate-limit-options.d.ts}

@@ -1,25 +1,13 @@
-import type { Redis } from 'ioredis';
-/**
- * Options to configure the rate limit plugin.
- *
- * @example
- * ```ts
- * const options: RateLimitOptions = {
- *   store: redisInstance, // Your Redis instance
- *   limit: 100,          // Allow 100 requests
- *   window: 60,          // Per 60 seconds
- * };
- * ```
- */
+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 Redis instance for persistent distributed storage
+     * - Provide a KvStore instance for persistent distributed storage
      */
-    readonly store?: ':memory:' | Redis;
+    readonly store?: ':memory:' | KvStore;
     /**
      * Maximum number of requests allowed in the time window.
      *

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

@@ -0,0 +1,2 @@
+export { JWT_ERROR_KEYS } from './jwt-error-keys';
+export { PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS } from './parse-human-time-to-seconds-error-keys';

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

@@ -0,0 +1,11 @@
+// @bun
+import {
+  JWT_ERROR_KEYS
+} from "../../../chunk-yagxbm1r.js";
+import {
+  PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS
+} from "../../../chunk-0601exyg.js";
+export {
+  PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS,
+  JWT_ERROR_KEYS
+};

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

@@ -0,0 +1,5 @@
+export declare const JWT_ERROR_KEYS: {
+    readonly JWT_EXPIRATION_PASSED: "jwt.error.expiration_passed";
+    readonly JWT_SECRET_NOT_FOUND: "jwt.error.secret_not_found";
+    readonly JWT_SIGN_ERROR: "jwt.error.sign_error";
+};

package/dist/modules/jwt/enums/parse-human-time-to-seconds-error-keys.d.ts

@@ -0,0 +1,3 @@
+export declare const PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS: {
+    readonly INVALID_TIME_EXPRESSION: "parse_human_time_to_seconds.error.invalid_time_expression";
+};

package/dist/modules/jwt/index.d.ts

@@ -0,0 +1 @@
+export { signJWT, verifyJWT } from './jwt';

package/dist/modules/jwt/index.js

@@ -0,0 +1,51 @@
+// @bun
+import {
+  JWT_ERROR_KEYS
+} from "../../chunk-yagxbm1r.js";
+import {
+  parseHumanTimeToSeconds
+} from "../../chunk-zwrygafm.js";
+import"../../chunk-0601exyg.js";
+import {
+  HttpError
+} from "../../chunk-00s6t4tw.js";
+import"../../chunk-h9t48r9q.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 : 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/jwt.d.ts

@@ -0,0 +1,3 @@
+import { type JWTPayload, type JWTVerifyResult } from 'jose';
+export declare const signJWT: (secret: string, payload: JWTPayload, expiration?: number | string | Date) => Promise<string>;
+export declare const verifyJWT: (token: string, secret: string) => Promise<JWTVerifyResult | false>;

package/dist/modules/jwt/utils/index.d.ts

@@ -0,0 +1 @@
+export { parseHumanTimeToSeconds } from './parse-human-time-to-seconds';

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

@@ -0,0 +1,9 @@
+// @bun
+import {
+  parseHumanTimeToSeconds
+} from "../../../chunk-zwrygafm.js";
+import"../../../chunk-0601exyg.js";
+import"../../../chunk-9cgzhc50.js";
+export {
+  parseHumanTimeToSeconds
+};

package/dist/modules/jwt/utils/parse-human-time-to-seconds.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Converts a human-readable time expression to seconds
+ *
+ * @param timeExpression - A string representing a time period (e.g., "2 hours", "30 minutes ago", "+1 day")
+ *
+ * @throws ({@link BaseError}) - If the time expression is invalid or contains an unknown unit
+ *
+ * @returns The time period in seconds (negative for past times)
+*
+ * @example
+ * ```typescript
+ * parseHumanTimeToSeconds("2 hours")      // Returns 7200
+ * parseHumanTimeToSeconds("30 mins ago")  // Returns -1800
+ * parseHumanTimeToSeconds("+1 day")       // Returns 86400
+ * ```
+ */
+export declare const parseHumanTimeToSeconds: (timeExpression: string) => number;

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

@@ -0,0 +1 @@
+export { KV_STORE_ERROR_KEYS } from './kv-store-error-keys';

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

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

package/dist/modules/kv-store/enums/kv-store-error-keys.d.ts

@@ -0,0 +1,5 @@
+export declare const KV_STORE_ERROR_KEYS: {
+    readonly CLOSING_CONNECTION_FAILED: "kv-store.error.closing_connection_failed";
+    readonly CONNECTION_FAILED: "kv-store.error.connection_failed";
+    readonly NOT_INTEGER: "kv-store.error.not_integer";
+};

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

@@ -0,0 +1 @@
+export { IoRedisStore } from './ioredis-store';

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

@@ -0,0 +1,92 @@
+// @bun
+import {
+  KV_STORE_ERROR_KEYS
+} from "../../../chunk-6tqh339a.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) {
+    const current = await this._client.get(key);
+    if (current !== null) {
+      const parsed = Number(current);
+      if (Number.isNaN(parsed))
+        throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER);
+    }
+    if (amount === 1)
+      return this._client.incr(key);
+    return this._client.incrby(key, amount);
+  }
+  async decrement(key, amount = 1) {
+    const current = await this._client.get(key);
+    if (current !== null) {
+      const parsed = Number(current);
+      if (Number.isNaN(parsed))
+        throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER);
+    }
+    if (amount === 1)
+      return this._client.decr(key);
+    return this._client.decrby(key, amount);
+  }
+  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

@@ -0,0 +1,107 @@
+import { type RedisOptions } from 'ioredis';
+import type { KvStore } from '../../../modules/kv-store/types/kv-store';
+/**
+ * Redis-based key-value store implementation using ioredis client.
+ *
+ * Provides a Redis-backed implementation of the KvStore interface with
+ * automatic JSON serialization/deserialization and proper error handling.
+ */
+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.d.ts

@@ -0,0 +1 @@
+export { MemoryStore } from './memory-store';

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

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