@mrxsys/mrx-core 2.7.0 → 2.8.0

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

@@ -1,4 +0,0 @@
-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

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

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

@@ -1,77 +0,0 @@
-// @bun
-import {
-  JWT_ERROR_KEYS
-} from "../../../chunk-cqw9xq4y.js";
-import {
-  HttpError
-} from "../../../chunk-683sda6e.js";
-import"../../../chunk-9nw6qekv.js";
-import"../../../chunk-vknq69e0.js";
-
-// source/modules/elysia/jwt/jwt.ts
-import { Elysia } from "elysia";
-import {
-  SignJWT,
-  jwtVerify
-} from "jose";
-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

@@ -1,119 +0,0 @@
-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

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

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

@@ -1,98 +0,0 @@
-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/rateLimit/stores/memoryStore.d.ts

@@ -1,47 +0,0 @@
-import type { RateLimitStore } from '../../../../modules/elysia/rateLimit/types/rateLimitStore';
-export declare class MemoryStore implements RateLimitStore {
-    /**
-     * Internal storage map.
-     */
-    private readonly _store;
-    /**
-     * Cleanup interval (5 minutes by default).
-     */
-    private readonly _cleanupInterval;
-    /**
-     * Timer for cleanup operations.
-     */
-    private _cleanupTimer;
-    /**
-     * Creates instance and starts cleanup process.
-     */
-    constructor(cleanupIntervalMs?: number);
-    /**
-     * Get current count for a key.
-     */
-    get(key: string): string | null;
-    /**
-     * Set key with expiration time.
-     */
-    setex(key: string, seconds: number, value: string): void;
-    /**
-     * Increment key value and return new count.
-     */
-    incr(key: string): number;
-    /**
-     * Get time to live for key in seconds.
-     */
-    ttl(key: string): number;
-    /**
-     * Start cleanup process.
-     */
-    private _startCleanup;
-    /**
-     * Clean up expired entries.
-     */
-    private _cleanup;
-    /**
-     * Stop cleanup and clear data.
-     */
-    destroy(): void;
-}

package/dist/modules/elysia/rateLimit/types/rateLimitStore.d.ts

@@ -1,21 +0,0 @@
-/**
- * Common interface for rate limit storage backends (Memory, Redis, etc.).
- */
-export interface RateLimitStore {
-    /**
-     * Get value for a key.
-     */
-    get(key: string): string | null | Promise<string | null>;
-    /**
-     * Set key with expiration.
-     */
-    setex(key: string, seconds: number, value: string): void | Promise<void>;
-    /**
-     * Increment key value.
-     */
-    incr(key: string): number | Promise<number>;
-    /**
-     * Get time to live for key.
-     */
-    ttl(key: string): number | Promise<number>;
-}