@mrxsys/mrx-core 2.4.0 → 2.5.0

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

@@ -0,0 +1,58 @@
+// @bun
+import {
+  HttpError
+} from "../../../chunk-84mqvfsk.js";
+import {
+  BaseError
+} from "../../../chunk-vknq69e0.js";
+
+// source/modules/elysia/error/error.ts
+import { Elysia } from "elysia";
+var error = new Elysia({
+  name: "errorPlugin"
+}).error({
+  BaseError,
+  HttpError
+}).onError(({ code, error: error2, set }) => {
+  set.headers["content-type"] = "application/json; charset=utf-8";
+  switch (code) {
+    case "HttpError":
+      set.status = error2.httpStatusCode;
+      return {
+        message: error2.message,
+        cause: error2.cause
+      };
+    case "BaseError":
+      set.status = 500;
+      return {
+        message: error2.message,
+        cause: error2.cause
+      };
+    case "VALIDATION": {
+      set.status = 422;
+      return {
+        message: "core.error.validation",
+        cause: {
+          on: error2.type,
+          found: error2.value,
+          errors: error2.all
+        }
+      };
+    }
+    case "NOT_FOUND":
+      set.status = 404;
+      return {
+        message: "core.error.not_found"
+      };
+    case "INTERNAL_SERVER_ERROR":
+    case "UNKNOWN":
+    default:
+      set.status = 500;
+      return {
+        message: "core.error.internal_server_error"
+      };
+  }
+}).as("global");
+export {
+  error
+};

package/dist/modules/elysia/jwt/enums/jwtErrorKeys.d.ts

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

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

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

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

@@ -0,0 +1,81 @@
+// @bun
+import {
+  HttpError
+} from "../../../chunk-84mqvfsk.js";
+import"../../../chunk-vknq69e0.js";
+
+// source/modules/elysia/jwt/jwt.ts
+import { Elysia } from "elysia";
+import {
+  SignJWT,
+  jwtVerify
+} from "jose";
+
+// source/modules/elysia/jwt/enums/jwtErrorKeys.ts
+var JWT_ERROR_KEYS = {
+  JWT_SIGN_ERROR: "elysia.jwt.error.sign_error",
+  JWT_SECRET_NOT_FOUND: "elysia.jwt.error.secret_not_found"
+};
+
+// source/modules/elysia/jwt/jwt.ts
+var jwt = (options) => {
+  if (!options.secret)
+    throw new HttpError({
+      message: JWT_ERROR_KEYS.JWT_SECRET_NOT_FOUND,
+      httpStatusCode: "INTERNAL_SERVER_ERROR"
+    });
+  const encodedKey = new TextEncoder().encode(options.secret);
+  const contextKeyName = options.jwtKeyName ?? "jwt";
+  const defaultAlgorithm = "HS256";
+  const defaultExpiration = "15m";
+  return new Elysia({
+    name: "jwt",
+    seed: options
+  }).decorate(contextKeyName, {
+    async sign(additionalPayload, expiration = options.exp ?? defaultExpiration) {
+      const jwtId = crypto.randomUUID();
+      const finalPayload = {
+        iss: "elysia-jwt-plugin",
+        aud: "elysia-application",
+        jti: jwtId,
+        iat: Math.floor(Date.now() / 1000),
+        ...options.payload,
+        ...additionalPayload
+      };
+      try {
+        const headerParams = {
+          alg: defaultAlgorithm,
+          typ: "JWT",
+          ...options.header ? Object.fromEntries(Object.entries(options.header).filter(([key]) => key !== "b64")) : {}
+        };
+        const jwt2 = new SignJWT(finalPayload).setProtectedHeader(headerParams).setIssuedAt().setExpirationTime(expiration);
+        if (finalPayload.iss)
+          jwt2.setIssuer(finalPayload.iss);
+        if (finalPayload.aud)
+          jwt2.setAudience(Array.isArray(finalPayload.aud) ? finalPayload.aud : [finalPayload.aud]);
+        return await jwt2.sign(encodedKey);
+      } catch (error) {
+        throw new HttpError({
+          message: JWT_ERROR_KEYS.JWT_SIGN_ERROR,
+          httpStatusCode: "INTERNAL_SERVER_ERROR",
+          cause: error
+        });
+      }
+    },
+    async verify(token) {
+      if (!token || token.trim() === "")
+        return false;
+      try {
+        const result = await jwtVerify(token, encodedKey, {
+          algorithms: [defaultAlgorithm]
+        });
+        return result;
+      } catch {
+        return false;
+      }
+    }
+  }).as("scoped");
+};
+export {
+  jwt
+};

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

@@ -0,0 +1,119 @@
+import { Elysia } from 'elysia';
+import { type JWTPayload, type JWTVerifyResult } from 'jose';
+import type { JWTOptions } from './types/jwtOptions';
+/**
+ * The `elysiaJwtPlugin` provides secure JSON Web Token (JWT) authentication capabilities for Elysia applications.
+ *
+ * This plugin leverages the industry-standard `jose` library to ensure robust JWT handling with modern cryptographic standards.
+ *
+ * @template TJWTKeyName - The name to use for JWT functionality in the Elysia context (defaults to 'jwt')
+ * @param options - Configuration options for the JWT plugin
+ *
+ * @returns An Elysia plugin that adds JWT functionality to the application context
+ *
+ * @throws ({@link HttpError}) - When the secret key is missing or invalid
+ *
+ * @example
+ * Basic usage
+ * ```ts
+ * const app = new Elysia()
+ *   .use(jwt({
+ *     secret: process.env.JWT_SECRET!,
+ *     exp: '1h'
+ *   }))
+ *   .post('/login', ({ jwt }) => {
+ *     return jwt.sign({ userId: 123, role: 'user' });
+ *   })
+ *   .get('/protected', async ({ jwt, headers }) => {
+ *     const token = headers.authorization?.replace('Bearer ', '');
+ *     const payload = await jwt.verify(token);
+ *     if (!payload) throw new Error('Invalid token');
+ *     return { user: payload };
+ *   });
+ * ```
+ * @example
+ * Custom context key name
+ * ```ts
+ * const app2 = new Elysia()
+ *   .use(jwt({
+ *     jwtKeyName: 'auth',
+ *     secret: 'my-secret'
+ *   }))
+ *   .post('/login', ({ auth }) => auth.sign({ id: 1 }));
+ * ```
+ */
+export declare const jwt: <const TJWTKeyName extends string = "jwt">(options: JWTOptions<TJWTKeyName>) => Elysia<"", {
+    decorator: { [name in TJWTKeyName]: {
+        /**
+         * Signs a JWT with the provided payload and optional expiration time.
+         *
+         * @param additionalPayload - Custom payload data to include in the JWT
+         * @param expiration - Token expiration time (overrides default if provided)
+         *
+         * @returns A Promise that resolves to the signed JWT string
+         *
+         * @throws ({@link HttpError}) - When JWT signing fails due to invalid payload or configuration
+         *
+         * @example
+         * Sign with user data
+         * ```ts
+         * const token = await jwt.sign({ userId: 123, role: 'admin' });
+         * ```
+         * @example
+         * Sign with custom expiration
+         * ```ts
+         * const token = await jwt.sign({ userId: 123 }, '2h');
+         * ````
+         * @example
+         * Sign with Date expiration
+         * ```ts
+         * const token = await jwt.sign({ userId: 123 }, new Date('2024-12-31'));
+         * ```
+         */
+        sign(additionalPayload?: JWTPayload, expiration?: number | string | Date): Promise<string>;
+        /**
+         * Verifies and decodes a JWT token.
+         *
+         * @param token - The JWT string to verify and decode
+         *
+         * @returns A Promise that resolves to the decoded payload or false if invalid
+         *
+         * @example
+         * Verify token from Authorization header
+         * ```ts
+         * const token = headers.authorization?.replace('Bearer ', '');
+         * const payload = await jwt.verify(token);
+         *
+         * if (payload) {
+         *   console.log('User ID:', payload.userId);
+         *   console.log('Token expires:', new Date(payload.exp! * 1000));
+         * } else {
+         *   console.log('Invalid or expired token');
+         * }
+         * ```
+         */
+        verify(token?: string): Promise<JWTVerifyResult | false>;
+    }; } extends infer T ? { [K in keyof T]: T[K]; } : never;
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: import("elysia").MergeSchema<{}, {}, "">;
+    standaloneSchema: import("elysia/types").PrettifySchema<{}>;
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}>;

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

@@ -0,0 +1 @@
+export type { JWTOptions } from './jwtOptions';

package/dist/modules/elysia/jwt/types/jwtOptions.d.ts

@@ -0,0 +1,98 @@
+import type { JWSHeaderParameters, JWTPayload } from 'jose';
+/**
+ * Configuration options for the JWT plugin.
+ *
+ * @template TJWTKeyName - The name to be used for accessing the JWT functionality in the Elysia context
+ *
+ * @example
+ * ```ts
+ * const options: JWTOption = {
+ *   name: 'auth',
+ *   secret: process.env.JWT_SECRET || 'your-secret-key',
+ *   exp: '1d',
+ *   header: {
+ *     alg: 'HS256',
+ *     typ: 'JWT'
+ *   },
+ *   payload: {
+ *     iss: 'my-api',
+ *     aud: 'my-client'
+ *   }
+ * };
+ * ```
+ */
+export interface JWTOptions<TJWTKeyName extends string = 'jwt'> {
+    /**
+    * JWT name to add in context with decorate.
+    *
+    * This allows you to customize how you access the JWT functionality in your
+    * route handlers. For example, if set to 'auth', you would use `auth.sign()`
+    * instead of the default `jwt.sign()`.
+    *
+    * @defaultValue 'jwt'
+    */
+    readonly jwtKeyName?: TJWTKeyName;
+    /**
+    * Secret key used to sign and verify JWTs.
+    *
+    * @example
+    * Using a string secret
+    * ```ts
+    * secret: 'your-very-secret-key'
+    *```
+    * @example
+    * Using an environment variable (recommended for production)
+    * ```ts
+    * secret: process.env.JWT_SECRET
+    * ```
+    */
+    readonly secret: string;
+    /**
+    * JWT expiration setting. Applies as the default expiration for tokens.
+    *
+    * Controls how long tokens are valid before they expire. This setting provides
+    * a good balance between security (limiting the window of opportunity for token misuse)
+    * and user experience (not requiring frequent re-authentication).
+    *
+    * @defaultValue '15m' (15 minutes)
+    *
+    * @example
+    * Set tokens to expire after 1 hour
+    * ```ts
+    * exp: '1h'
+    * ```
+    * @example
+    * Set tokens to expire at a specific date
+    * ```ts
+    * exp: new Date('2023-12-31')
+    * ```
+    * @example
+    * Set tokens to expire after 3600 seconds (1 hour)
+    * ```ts
+    * exp: 3600
+    * ```
+    */
+    readonly exp?: number | string | Date;
+    /**
+    * Default JWT header parameters to include in every JWT.
+    *
+    * This allows you to specify additional metadata about the token.
+    */
+    readonly header?: JWSHeaderParameters;
+    /**
+    * Default payload values to include in every JWT.
+    *
+    * These values are merged with any additional payload provided during signing,
+    * allowing you to set standard claims that should be included in all tokens
+    * generated by your application.
+    *
+    * @example
+    * ```ts
+    * payload: {
+    *   iss: 'my-api',           // Issuer
+    *   aud: 'my-frontend',      // Audience
+    * }
+    * ```
+    */
+    readonly payload?: JWTPayload;
+}

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

@@ -0,0 +1 @@
+export { microservice } from './microservice';

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

@@ -0,0 +1,96 @@
+// @bun
+// source/modules/elysia/microservice/microservice.ts
+import { Elysia } from "elysia";
+import { existsSync } from "fs";
+import { platform } from "os";
+
+// source/modules/elysia/microservice/schemas/info.ts
+import { t } from "elysia";
+var infoResponse200Schema = t.Object({
+  message: t.String({
+    description: "Message",
+    example: "Microservice Information"
+  }),
+  content: t.Object({
+    author: t.String({
+      description: "Author",
+      example: "Ruby"
+    }),
+    name: t.String({
+      description: "Name",
+      example: "API"
+    }),
+    version: t.String({
+      description: "Version",
+      example: "1.0.0"
+    }),
+    description: t.String({
+      description: "Description",
+      example: "Is a microservice that provides a RESTful API for the application."
+    })
+  })
+});
+
+// source/modules/elysia/microservice/schemas/ping.ts
+import { t as t2 } from "elysia";
+var pingResponse200Schema = t2.Object({
+  message: t2.String({
+    description: "Message",
+    example: "pong"
+  })
+});
+
+// source/modules/elysia/microservice/microservice.ts
+var findPackageJson = (path) => {
+  const isWin = platform() === "win32";
+  const separator = isWin ? "\\" : "/";
+  if (isWin && /^[A-Z]:\\$/i.test(path) || !isWin && path === "/")
+    return "";
+  const packageJsonPath = path + separator + "package.json";
+  if (existsSync(packageJsonPath))
+    return packageJsonPath;
+  const pathParts = path.split(separator);
+  if (pathParts.length <= 1)
+    return "";
+  const newPath = pathParts.slice(0, -1).join(separator);
+  if (newPath === "")
+    return "";
+  return findPackageJson(newPath);
+};
+var packageJson = await import(findPackageJson(Bun.main));
+var microservice = new Elysia({
+  name: "microservicePlugin",
+  prefix: "/microservice",
+  detail: {
+    tags: ["Microservice"],
+    security: []
+  }
+}).model({
+  infoResponse200: infoResponse200Schema,
+  pingResponse200: pingResponse200Schema
+}).get("/ping", () => ({
+  message: "pong"
+}), {
+  detail: {
+    summary: "Ping",
+    description: "Ping the microservice to check if it is alive"
+  },
+  response: "pingResponse200"
+}).get("/info", () => ({
+  message: "Microservice Information",
+  content: {
+    name: packageJson.default.name,
+    version: packageJson.default.version,
+    description: packageJson.default.description,
+    author: packageJson.default.author
+  }
+}), {
+  detail: {
+    summary: "Info",
+    description: "Get information about the microservice"
+  },
+  response: "infoResponse200"
+}).as("scoped");
+export {
+  microservice
+};

package/dist/{elysia → modules/elysia/microservice}/microservice.d.ts

@@ -6,7 +6,7 @@ import { Elysia } from 'elysia';
  * - `/ping`: Checks if the microservice is alive.
  * - `/info`: Provides information about the microservice.
  */
-export declare const microservicePlugin: Elysia<"/microservice", {
+export declare const microservice: Elysia<"/microservice", {
     decorator: {};
     store: {};
     derive: {};

package/dist/modules/elysia/ratelimit/enums/ratelimitErrorKeys.d.ts

@@ -0,0 +1,3 @@
+export declare const RATELIMIT_ERROR_KEYS: {
+    readonly RATELIMIT_EXCEEDED: "elysia.ratelimit.error.exceeded";
+};

package/dist/modules/elysia/ratelimit/index.d.ts

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

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

@@ -0,0 +1,55 @@
+// @bun
+import {
+  HttpError
+} from "../../../chunk-84mqvfsk.js";
+import"../../../chunk-vknq69e0.js";
+
+// source/modules/elysia/ratelimit/ratelimit.ts
+import { Elysia } from "elysia";
+
+// source/modules/elysia/ratelimit/enums/ratelimitErrorKeys.ts
+var RATELIMIT_ERROR_KEYS = {
+  RATELIMIT_EXCEEDED: "elysia.ratelimit.error.exceeded"
+};
+
+// source/modules/elysia/ratelimit/ratelimit.ts
+var rateLimit = ({ redis, limit, window }) => new Elysia({
+  name: "rateLimit",
+  seed: {
+    redis,
+    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 current = await redis.get(key);
+  const count = current ? parseInt(current) : 0;
+  if (count === 0)
+    await redis.setex(key, window, "1");
+  else
+    await redis.incr(key);
+  const newCount = await redis.get(key);
+  const currentCount = newCount ? parseInt(newCount) : 0;
+  if (currentCount > limit) {
+    set.status = 429;
+    throw new HttpError({
+      message: RATELIMIT_ERROR_KEYS.RATELIMIT_EXCEEDED,
+      httpStatusCode: "TOO_MANY_REQUESTS",
+      cause: {
+        limit,
+        window,
+        remaining: 0,
+        reset: await redis.ttl(key)
+      }
+    });
+  }
+  set.headers = {
+    "X-RateLimit-Limit": limit.toString(),
+    "X-RateLimit-Remaining": Math.max(0, limit - currentCount).toString(),
+    "X-RateLimit-Reset": (await redis.ttl(key)).toString()
+  };
+}).as("scoped");
+export {
+  rateLimit
+};

package/dist/{elysia → modules/elysia/ratelimit}/ratelimit.d.ts

@@ -5,11 +5,6 @@ import type { RateLimitOptions } from './types/rateLimitOptions';
  * 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.
  *
- * The plugin uses Redis for tracking request counts, making it suitable for distributed
- * environments where multiple server instances may be handling requests from the same client.
- * When a client exceeds the configured request limit, the plugin returns a 429 Too Many Requests
- * response with appropriate headers indicating the limit and reset time.
- *
  * ### Rate Limit Headers:
  * The plugin adds the following headers to all responses:
  * - `X-RateLimit-Limit`: The maximum number of requests allowed in the window
@@ -21,11 +16,7 @@ import type { RateLimitOptions } from './types/rateLimitOptions';
  * @returns An {@link Elysia} plugin that adds rate limiting functionality
  *
  * @example
- * ```typescript
- * import { Elysia } from 'elysia';
- * import { Redis } from '#/core/store/redis';
- * import { rateLimitPlugin } from '#/core/elysia/plugin/ratelimit';
- *
+ * ```ts
  * // Create Redis instance
  * const redis = new Redis({
  *   host: 'localhost',
@@ -35,11 +26,10 @@ import type { RateLimitOptions } from './types/rateLimitOptions';
  *
  * // Create and configure the application with rate limiting
  * const app = new Elysia()
- *   .use(rateLimitPlugin({
+ *   .use(rateLimit({
  *     redis,
  *     limit: 100,           // 100 requests
  *     window: 60,           // per minute
- *     message: 'Too many requests, please try again later.'
  *   }))
  *   .get('/public-api', () => {
  *     return { success: true, message: 'This endpoint is rate limited' };
@@ -49,7 +39,7 @@ import type { RateLimitOptions } from './types/rateLimitOptions';
  * app.listen(3000);
  * ```
  */
-export declare const rateLimitPlugin: ({ redis, limit, window, message }: RateLimitOptions) => Elysia<"", {
+export declare const rateLimit: ({ redis, limit, window }: RateLimitOptions) => Elysia<"", {
     decorator: {};
     store: {};
     derive: {};

package/dist/modules/elysia/ratelimit/types/index.d.ts

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

package/dist/{elysia → modules/elysia/ratelimit}/types/rateLimitOptions.d.ts

@@ -1,9 +1,9 @@
-import type { Redis } from '../../store/redis';
+import type { Redis } from 'ioredis';
 /**
  * Options to configure the rate limit plugin.
  *
  * @example
- * ```typescript
+ * ```ts
  * const options: RateLimitOptions = {
  *   redis: redisInstance, // Your Redis instance
  *   limit: 100,          // Allow 100 requests
@@ -14,31 +14,21 @@ import type { Redis } from '../../store/redis';
  */
 export interface RateLimitOptions {
     /**
-     * The Redis instance to store rate limit data.
-     * @see {@link Redis}
+     * Redis instance used for storing rate limit data.
      */
-    redis: Redis;
+    readonly redis: Redis;
     /**
      * Maximum number of requests allowed in the time window.
      *
      * This defines how many requests a client can make within the specified time window
      * before rate limiting is applied.
      */
-    limit: number;
+    readonly limit: number;
     /**
      * Time window in seconds during which the request limit applies.
      *
      * This defines the duration of the rate limiting window. For example, a window of 60
      * with a limit of 100 allows 100 requests per minute per client.
      */
-    window: number;
-    /**
-     * Custom error message when rate limit is exceeded.
-     *
-     * If provided, this message will be included in the error response when a client
-     * exceeds their rate limit. If not provided, a default message is used.
-     *
-     * @defaultValue 'Rate limit exceeded'
-     */
-    message?: string;
+    readonly window: number;
 }

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

@@ -0,0 +1,6 @@
+export declare const LOGGER_ERROR_KEYS: {
+    readonly STRATEGY_ALREADY_ADDED: "logger.error.strategy_already_added";
+    readonly STRATEGY_NOT_FOUND: "logger.error.strategy_not_found";
+    readonly NO_STRATEGY_ADDED: "logger.error.no_strategy_added";
+    readonly STRATEGY_ERROR: "logger.error.strategy_error";
+};

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

@@ -0,0 +1 @@
+export type { LoggerEvent } from './loggerEvents';

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

@@ -0,0 +1,11 @@
+import type { BaseError } from '../../../errors/baseError';
+export interface LoggerEvent {
+    readonly error: [
+        BaseError<{
+            strategyName: string;
+            object: unknown;
+            error: Error;
+        }>
+    ];
+    readonly end: [];
+}

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

@@ -0,0 +1 @@
+export { Logger } from './logger';