tezx 3.0.9-beta → 3.0.11-beta

package/index.js

@@ -1,9 +1,11 @@
+import { TezXError } from "./core/error.js";
 import { Router } from "./core/router.js";
 import { TezX } from "./core/server.js";
-export { Router, TezX };
-export let version = "3.0.9-beta";
+export { Router, TezX, TezXError };
+export let version = "3.0.11-beta";
 export default {
     Router,
     TezX,
     version,
+    TezXError,
 };

package/middleware/basic-auth.d.ts

@@ -1,83 +1,55 @@
 import { Context } from "../core/context.js";
 import { HttpBaseResponse, Middleware } from "../types/index.js";
 /**
- * Supported authentication method types.
+ * Options for Basic Authentication middleware.
  */
-export type AuthMethod = "basic" | "api-key" | "bearer-token";
-export type AuthCredential = {
-    username?: any;
-    password?: any;
-    token?: any;
-    apiKey?: any;
-};
-/**
- * Configuration options for dynamic basic authentication.
- */
-export type DynamicBasicAuthOptions = {
+export type BasicAuthOptions = {
     /**
-     * 🔐 Function to validate the provided credentials.
-     * @param method - The method of authentication.
-     * @param credentials - The extracted credentials.
+     * Function to validate the username and password.
+     * Can return a boolean or a Promise<boolean>.
+     *
+     * @param username - The username extracted from the request.
+     * @param password - The password extracted from the request.
      * @param ctx - The current request context.
-     * @returns A boolean or Promise resolving to whether the credentials are valid.
+     * @returns Whether the credentials are valid.
      */
-    validateCredentials: (method: AuthMethod, credentials: AuthCredential, ctx: Context) => boolean | Promise<boolean>;
+    validate: (username: string, password: string, ctx: Context) => boolean | Promise<boolean>;
     /**
-     * 🔒 Function to dynamically determine the realm for authentication prompt.
-     * @param ctx - The current request context.
-     * @returns The authentication realm string.
+     * Realm name shown in the `WWW-Authenticate` header.
+     * Defaults to `"Restricted Area"`.
      */
-    getRealm?: (ctx: Context) => string;
+    realm?: string;
     /**
-     * ❌ Custom handler for unauthorized access.
+     * Custom handler for unauthorized requests.
+     *
      * @param ctx - The current request context.
-     * @param error - Optional error information.
-     * @returns A CallbackReturn to end the response.
+     * @param error - Optional error object describing why access was denied.
+     * @returns HttpBaseResponse to send to the client.
      */
     onUnauthorized?: (ctx: Context, error?: Error) => HttpBaseResponse;
-    /**
-     * 🚦 Rate-limiting configuration.
-     *  @requires getConnInfo middleware. for parse remote address.
-     */
-    rateLimit?: {
-        /**
-         * 🧠 Custom cache or storage for rate-limit tracking.
-         */
-        storage?: {
-            get: (key: string) => {
-                count: number;
-                resetTime: number;
-            } | undefined;
-            set: (key: string, value: {
-                count: number;
-                resetTime: number;
-            }) => void;
-            clearExpired: () => void;
-        };
-        /** 🔁 Max requests allowed within the window */
-        maxRequests: number;
-        /** ⏲️ Duration of window in milliseconds */
-        windowMs: number;
-    };
-    /**
-     * 🛠 Supported authentication types.
-     * @default ["basic"]
-     */
-    supportedMethods?: AuthMethod[];
-    /**
-     * 🧑‍⚖️ Optional RBAC (Role-Based Access Control) check.
-     * @param ctx - The current request context.
-     * @param credentials - The validated credentials.
-     * @returns Whether access is allowed.
-     */
-    checkAccess?: (ctx: Context, credentials: AuthCredential) => boolean | Promise<boolean>;
 };
 /**
- * 🔐 Middleware for flexible authentication using Basic, API Key, or Bearer Token.
- * Supports rate limiting, IP filtering, and role-based access control.
+ * Basic Authentication Middleware
+ *
+ * Verifies that incoming requests contain a valid Basic Auth header
+ * (`Authorization: Basic <base64-credentials>`). Supports async
+ * validation and custom unauthorized handling.
+ *
+ * @param options - Configuration options for validation, realm, and error handling.
+ * @returns Middleware function to use in routes.
+ *
+ * @example
+ * ```ts
+ * import basicAuth from "./middleware/basicAuth.js";
+ *
+ * const auth = basicAuth({
+ *   validate: async (username, password) => username === "admin" && password === "1234",
+ * });
  *
- * @param options - Custom authentication handler options.
- * @returns A middleware function.
+ * app.use("/admin", auth, (ctx) => {
+ *   ctx.json({ message: "Access granted" });
+ * });
+ * ```
  */
-declare const basicAuth: (options: DynamicBasicAuthOptions) => Middleware;
-export { basicAuth, basicAuth as default };
+export declare const basicAuth: <T extends Record<string, any> = {}, Path extends string = any>(options: BasicAuthOptions) => Middleware<T, Path>;
+export default basicAuth;

package/middleware/basic-auth.js

@@ -1,69 +1,43 @@
 import { Buffer } from "node:buffer";
-import { GlobalConfig } from "../core/config.js";
-import { colorText } from "../utils/colors.js";
-import { createRateLimitDefaultStorage, isRateLimit, } from "../utils/rateLimit.js";
-const basicAuth = (options) => {
-    const { validateCredentials, getRealm = () => "Restricted Area", onUnauthorized = (ctx, error) => {
-        const realm = getRealm(ctx);
+export const basicAuth = (options) => {
+    const { validate, realm = "Restricted Area", onUnauthorized = (ctx, error) => {
         ctx.setStatus = 401;
         ctx.setHeader("WWW-Authenticate", `Basic realm="${realm}"`);
-        ctx.body = { error: error?.message };
-    }, rateLimit, supportedMethods = ["basic", "api-key", "bearer-token"], checkAccess, } = options;
-    let storage = rateLimit?.storage;
-    if (rateLimit && !rateLimit.storage) {
-        storage = createRateLimitDefaultStorage();
-    }
-    return async function basicAuth(ctx, next) {
-        let authMethod;
-        let credentials = {};
+        return ctx.json({ error: error?.message || "Unauthorized" });
+    }, } = options;
+    return async (ctx, next) => {
         const auth = ctx.req.header("authorization");
-        if (auth) {
-            if (auth.startsWith("Basic ")) {
-                authMethod = "basic";
-                const base64Credentials = auth.split(" ")[1];
-                const decoded = Buffer.from(base64Credentials, "base64").toString("utf-8");
-                const [username, password] = decoded.split(":");
-                credentials = { username, password };
-            }
-            else if (auth.startsWith("Bearer ")) {
-                authMethod = "bearer-token";
-                credentials = { token: auth.split(" ")[1] };
-            }
+        if (!auth || !auth.startsWith("Basic ")) {
+            return onUnauthorized(ctx, new Error("Basic authentication required"));
         }
-        else if (ctx.header("x-api-key")) {
-            authMethod = "api-key";
-            credentials = { apiKey: ctx.header("x-api-key") };
+        const base64 = auth.slice(6).trim();
+        if (!base64) {
+            return onUnauthorized(ctx, new Error("Empty credentials"));
         }
-        if (!authMethod || !supportedMethods.includes(authMethod)) {
-            GlobalConfig.debugging.error(`${colorText("[AUTH]", "bgRed")} Unsupported or missing authentication method.`);
-            return onUnauthorized(ctx, new Error("Unsupported authentication method"));
+        let username, password;
+        try {
+            const decoded = Buffer.from(base64, "base64").toString("utf-8");
+            const idx = decoded.indexOf(":");
+            if (idx === -1)
+                throw new Error("Missing colon in credentials");
+            username = decoded.slice(0, idx);
+            password = decoded.slice(idx + 1);
         }
-        if (rateLimit) {
-            let key = `${ctx.req.remoteAddress.address}:${ctx.req.remoteAddress.port}`;
-            const { check, entry } = isRateLimit(ctx, key, storage, rateLimit.maxRequests, rateLimit.windowMs);
-            if (check) {
-                const retryAfter = Math.ceil((entry.resetTime - Date.now()) / 1000);
-                ctx.setHeader("Retry-After", retryAfter.toString());
-                return onUnauthorized(ctx, new Error(`Rate limit exceeded. Retry after ${retryAfter} seconds.`));
-            }
+        catch (err) {
+            return onUnauthorized(ctx, new Error("Invalid Basic auth format"));
         }
         try {
-            const isValid = await validateCredentials(authMethod, credentials, ctx);
-            if (!isValid) {
-                throw new Error("Invalid credentials.");
-            }
-            if (checkAccess) {
-                const hasAccess = await checkAccess(ctx, credentials);
-                if (!hasAccess) {
-                    return onUnauthorized(ctx, new Error("Access denied."));
-                }
+            const valid = await validate(username, password, ctx);
+            if (!valid) {
+                return onUnauthorized(ctx, new Error("Invalid username or password"));
             }
-            return await next();
+            ctx.user = { username };
+            await next();
         }
-        catch (error) {
-            GlobalConfig.debugging.error(`${colorText("[AUTH]", "bgRed")} Failure for method: ${ctx.method}`);
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
             return onUnauthorized(ctx, error);
         }
     };
 };
-export { basicAuth, basicAuth as default };
+export default basicAuth;

package/middleware/bearer-auth.d.ts

@@ -0,0 +1,52 @@
+import { Context } from "../core/context.js";
+import { HttpBaseResponse, Middleware } from "../types/index.js";
+/**
+ * Options for Bearer Authentication middleware.
+ */
+export type BearerAuthOptions = {
+    /**
+     * Function to validate the token.
+     * Can be synchronous or asynchronous.
+     * @param token - The Bearer token from the request.
+     * @param ctx - The current request context.
+     * @returns Boolean indicating if the token is valid.
+     */
+    validate: (token: string, ctx: Context) => boolean | Promise<boolean>;
+    /**
+     * Realm name shown in the `WWW-Authenticate` header.
+     * Defaults to `"API"`.
+     */
+    realm?: string;
+    /**
+     * Custom handler for unauthorized requests.
+     * @param ctx - The current request context.
+     * @param error - Optional error object describing the reason.
+     * @returns HttpBaseResponse to send to the client.
+     */
+    onUnauthorized?: (ctx: Context, error?: Error) => HttpBaseResponse;
+};
+/**
+ * Bearer Authentication Middleware
+ *
+ * Verifies that incoming requests contain a valid Bearer token
+ * in the `Authorization` header. Supports async token validation
+ * and custom error handling.
+ *
+ * @param options - Configuration options for token validation, realm, and error handling.
+ * @returns Middleware function to use in routes.
+ *
+ * @example
+ * ```ts
+ * import { bearerAuth } from "./middleware/bearerAuth.js";
+ *
+ * const auth = bearerAuth({
+ *   validate: async (token) => token === "secret-token",
+ * });
+ *
+ * app.use("/api", auth, (ctx) => {
+ *   ctx.json({ message: "Access granted" });
+ * });
+ * ```
+ */
+export declare const bearerAuth: <T extends Record<string, any> = {}, Path extends string = any>(options: BearerAuthOptions) => Middleware<T, Path>;
+export default bearerAuth;

package/middleware/bearer-auth.js

@@ -0,0 +1,30 @@
+export const bearerAuth = (options) => {
+    const { validate, realm = "API", onUnauthorized = (ctx, error) => {
+        ctx.setStatus = 401;
+        ctx.setHeader("WWW-Authenticate", `Bearer realm="${realm}"`);
+        return ctx.json({ error: error?.message || "Unauthorized" });
+    }, } = options;
+    return async (ctx, next) => {
+        const auth = ctx.req.header("authorization");
+        if (!auth || !auth.startsWith("Bearer ")) {
+            return onUnauthorized(ctx, new Error("Bearer token required"));
+        }
+        const token = auth.slice(7).trim();
+        if (!token) {
+            return onUnauthorized(ctx, new Error("Empty token"));
+        }
+        try {
+            const valid = await validate(token, ctx);
+            if (!valid) {
+                return onUnauthorized(ctx, new Error("Invalid or expired token"));
+            }
+            ctx.token = token;
+            await next();
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            return onUnauthorized(ctx, error);
+        }
+    };
+};
+export default bearerAuth;

package/middleware/cors.d.ts

@@ -1,11 +1,10 @@
-import { Ctx } from "../types/index.js";
+import { Middleware } from "../types/index.js";
 export type CorsOptions = {
     /**
      * Allowed origins for CORS.
-     * Can be a string, a RegExp, an array of strings or RegExps, or a function
-     * that takes the request origin and returns a boolean indicating if it is allowed.
+     * Can be a string, an array of strings, or a function that returns a boolean.
      */
-    origin?: string | RegExp | (string | RegExp)[] | ((reqOrigin: string) => boolean);
+    origin?: string | string[] | ((reqOrigin: string) => boolean);
     /**
      * Allowed HTTP methods for CORS requests.
      * Defaults to ['GET', 'POST', 'PUT', 'DELETE'].
@@ -21,31 +20,18 @@ export type CorsOptions = {
      */
     exposedHeaders?: string[];
     /**
-     * Indicates whether the response to the request can be exposed
-     * when the credentials flag is true.
+     * Indicates whether credentials are allowed.
      */
     credentials?: boolean;
     /**
-     * Indicates how long the results of a preflight request
-     * can be cached (in seconds).
+     * Preflight cache duration in seconds.
      */
     maxAge?: number;
 };
 /**
  * Middleware for handling Cross-Origin Resource Sharing (CORS).
  *
- * @param {CorsOptions} [option={}] - Configuration options for CORS.
- * @returns {Function} Middleware function compatible with the framework's middleware signature.
- *
- * @example
- * ```ts
- * app.use(cors({
- *   origin: ["https://example.com", /https:\/\/.*\.example\.com/],
- *   methods: ["GET", "POST"],
- *   credentials: true,
- *   maxAge: 600,
- * }));
- * ```
+ * @param option - Configuration options for CORS.
  */
-declare function cors(option?: CorsOptions): (ctx: Ctx, next: () => Promise<any>) => Promise<any>;
+declare function cors<T extends Record<string, any> = {}, Path extends string = any>(option?: CorsOptions): Middleware<T, Path>;
 export { cors, cors as default };

package/middleware/cors.js

@@ -1,45 +1,35 @@
 function cors(option = {}) {
-    const { methods, allowedHeaders, credentials, exposedHeaders, maxAge, origin, } = option;
+    const { credentials, maxAge, origin, } = option;
+    let methods = (option.methods || ["GET", "POST", "PUT", "DELETE"]).join(", ");
+    let allowedHeaders = (option.allowedHeaders || ["Content-Type", "Authorization"]).join(", ");
+    let exposedHeaders = option?.exposedHeaders?.join(", ");
     return async function cors(ctx, next) {
         const reqOrigin = ctx.req.header("origin") || "";
         let allowOrigin = "*";
         if (typeof origin === "string") {
             allowOrigin = origin;
         }
-        else if (origin instanceof RegExp) {
-            allowOrigin = origin.test(reqOrigin) ? reqOrigin : "";
-        }
         else if (Array.isArray(origin)) {
-            const isAllowed = origin.some((item) => {
-                if (typeof item === "string") {
-                    return item === reqOrigin;
-                }
-                else if (item instanceof RegExp) {
-                    return item.test(reqOrigin);
-                }
-            });
-            allowOrigin = isAllowed ? reqOrigin : "";
+            allowOrigin = origin.includes(reqOrigin) ? reqOrigin : "";
         }
         else if (typeof origin === "function") {
             allowOrigin = origin(reqOrigin) ? reqOrigin : "";
         }
-        ctx.setHeader("Access-Control-Allow-Origin", allowOrigin);
-        ctx.setHeader("Access-Control-Allow-Methods", (methods || ["GET", "POST", "PUT", "DELETE"]).join(", "));
-        ctx.setHeader("Access-Control-Allow-Headers", (allowedHeaders || ["Content-Type", "Authorization"]).join(", "));
+        ctx.headers.set("Access-Control-Allow-Origin", allowOrigin);
+        ctx.headers.set("Access-Control-Allow-Methods", methods);
+        ctx.headers.set("Access-Control-Allow-Headers", allowedHeaders);
         if (exposedHeaders) {
-            ctx.setHeader("Access-Control-Expose-Headers", exposedHeaders.join(", "));
+            ctx.headers.set("Access-Control-Expose-Headers", exposedHeaders);
         }
         if (credentials) {
-            ctx.setHeader("Access-Control-Allow-Credentials", "true");
+            ctx.headers.set("Access-Control-Allow-Credentials", "true");
         }
         if (maxAge) {
-            ctx.setHeader("Access-Control-Max-Age", maxAge.toString());
+            ctx.headers.set("Access-Control-Max-Age", maxAge.toString());
         }
-        if (ctx.req.method === "OPTIONS") {
-            return new Response(null, {
-                status: 204,
-                headers: ctx.header(),
-            });
+        if (ctx.method === "OPTIONS") {
+            ctx.setStatus = 204;
+            return;
         }
         return await next();
     };

package/middleware/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./basic-auth.js";
+export * from "./bearer-auth.js";
+export * from "./cors.js";
+export * from "./logger.js";
+export * from "./pagination.js";
+export * from "./powered-by.js";
+export * from "./request-id.js";
+export * from "./sanitize-headers.js";
+export * from "./xss-protection.js";

package/middleware/index.js

@@ -0,0 +1,9 @@
+export * from "./basic-auth.js";
+export * from "./bearer-auth.js";
+export * from "./cors.js";
+export * from "./logger.js";
+export * from "./pagination.js";
+export * from "./powered-by.js";
+export * from "./request-id.js";
+export * from "./sanitize-headers.js";
+export * from "./xss-protection.js";

package/middleware/logger.d.ts

@@ -12,5 +12,7 @@ import { Middleware } from "../types/index.js";
  * app.use(logger());
  * ```
  */
-declare function logger(): Middleware;
+declare function logger(options?: {
+    enabled: boolean;
+}): Middleware;
 export { logger, logger as default };

package/middleware/logger.js

@@ -1,13 +1,16 @@
 import { colorText } from "../utils/colors.js";
-function logger() {
+function logger(options = { enabled: true }) {
     return async function logger(ctx, next) {
         try {
+            if (!options?.enabled) {
+                return next();
+            }
             console.log(`${colorText("<--", "bold")} ${colorText(ctx.method, "bgMagenta")} ${ctx.pathname}`);
             const startTime = performance.now();
-            let n = await next();
+            let n = (await next());
             const elapsed = performance.now() - startTime;
             console.log(`${colorText("-->", "bold")} ${colorText(ctx.method, "bgBlue")} ${ctx.pathname} ` +
-                `${colorText(ctx.getStatus, "yellow")} ${colorText(`${elapsed.toFixed(2)}ms`, "magenta")}`);
+                `${colorText(n ? ctx.getStatus : 404, "yellow")} ${colorText(`${elapsed.toFixed(2)}ms`, "magenta")}`);
             return n;
         }
         catch (err) {

package/middleware/pagination.d.ts

@@ -1,5 +1,5 @@
-import { Context, Middleware } from "../index.js";
-export type PaginationOptions = {
+import { Context } from "../index.js";
+export type PaginationOptions<DataKey extends string = "data", CountKey extends string = "total", Item = any> = {
     /**
      * 🔢 Default page number when not specified
      * @default 1
@@ -35,13 +35,13 @@ export type PaginationOptions = {
      * @default "total"
      * @example "totalCount" // Read from response.totalCount
      */
-    countKey?: string;
+    countKey?: CountKey;
     /**
      * 📦 Key containing the data array in response
      * @default "data"
      * @example "items" // Process response.items array
      */
-    dataKey?: string;
+    dataKey?: DataKey;
     /**
      * 🛠️ Function to fetch data dynamically
      * @param ctx - Request context
@@ -57,7 +57,9 @@ export type PaginationOptions = {
         limit: number;
         offset: number;
     }) => Promise<{
-        [key: string]: any;
+        [K in DataKey]: Item[];
+    } & {
+        [K in CountKey]: number;
     }>;
 };
 export type PaginationBodyType = {
@@ -100,5 +102,5 @@ export type PaginationBodyType = {
  *   }
  * }));
  */
-declare const paginationHandler: (options?: PaginationOptions) => Middleware;
+declare const paginationHandler: <DataKey extends string = "data", CountKey extends string = "total", Item = any>(options?: PaginationOptions<DataKey, CountKey, Item>) => any;
 export { paginationHandler, paginationHandler as default };

package/middleware/pagination.js

@@ -1,5 +1,5 @@
 const paginationHandler = (options = {}) => {
-    const { defaultPage = 1, defaultLimit = 10, maxLimit = 100, queryKeyPage = "page", queryKeyLimit = "limit", countKey = "total", dataKey = "data", getDataSource, } = options;
+    let { defaultPage = 1, defaultLimit = 10, maxLimit = 100, queryKeyPage = "page", queryKeyLimit = "limit", countKey = "total", dataKey = "data", getDataSource, } = options;
     return async function paginationHandler(ctx, next) {
         const rawPage = ctx.req.query[queryKeyPage];
         const rawLimit = ctx.req.query[queryKeyLimit];

package/middleware/powered-by.js

@@ -1,6 +1,6 @@
 const poweredBy = (serverName) => {
     return function poweredBy(ctx, next) {
-        ctx.setHeader("x-powered-by", serverName || "TezX");
+        ctx.headers.set("x-powered-by", serverName || "TezX");
         return next();
     };
 };

package/middleware/rate-limiter.d.ts

@@ -20,10 +20,6 @@ export type RateLimiterOptions = {
      * keyGenerator: (ctx) => ctx.user?.id || ctx.ip // Use user ID if authenticated
      */
     keyGenerator?: (ctx: Context) => string;
-    /**
-        //  * ⚠️ (Future) Storage backend - currently memory only
-        //  * @todo Implement Redis storage
-        //  */
     /**
      * 🔄 Custom cache storage implementation (e.g., using `Map`, `Redis`, etc.).
      * By default, it uses a `Map<string, { count: number; resetTime: number }>`.

package/middleware/rate-limiter.js

@@ -1,20 +1,33 @@
+import { TezXError } from "../core/error.js";
 import { createRateLimitDefaultStorage, isRateLimit, } from "../utils/rateLimit.js";
 const rateLimiter = (options) => {
-    const { maxRequests, windowMs, keyGenerator = (ctx) => `${ctx.req.remoteAddress.address}:${ctx.req.remoteAddress.port}`, storage = createRateLimitDefaultStorage(), onError = (ctx, retryAfter, error) => {
+    const { maxRequests, windowMs, keyGenerator = (ctx) => {
+        const xForwardedFor = ctx.req.header("x-forwarded-for");
+        if (xForwardedFor) {
+            const ip = xForwardedFor.split(",")[0].trim();
+            return ip;
+        }
+        const clientIp = ctx.req.header("client-ip");
+        if (clientIp)
+            return clientIp;
+        const addr = ctx.req.remoteAddress?.address || "unknown";
+        const port = ctx.req.remoteAddress?.port || "0";
+        return `${addr}:${port}`;
+    }, storage = createRateLimitDefaultStorage(), onError = (ctx, retryAfter, error) => {
         ctx.setStatus = 429;
-        throw new Error(`Rate limit exceeded. Try again in ${retryAfter} seconds.`);
+        throw new TezXError(`Rate limit exceeded. Try again in ${retryAfter} seconds.`, 429);
     }, } = options;
     return async function rateLimiter(ctx, next) {
         const key = keyGenerator(ctx);
-        const { check, entry } = isRateLimit(ctx, key, storage, maxRequests, windowMs);
+        const { check, entry } = isRateLimit(key, storage, maxRequests, windowMs);
         if (check) {
             const retryAfter = Math.ceil((entry.resetTime - Date.now()) / 1000);
-            ctx.setHeader("Retry-After", retryAfter.toString());
+            ctx.headers.set("Retry-After", retryAfter.toString());
             return onError(ctx, retryAfter, new Error(`Rate limit exceeded. Retry after ${retryAfter} seconds.`));
         }
-        ctx.setHeader("X-RateLimit-Limit", maxRequests.toString());
-        ctx.setHeader("X-RateLimit-Remaining", (maxRequests - entry.count).toString());
-        ctx.setHeader("X-RateLimit-Reset", entry.resetTime.toString());
+        ctx.headers.set("X-RateLimit-Limit", maxRequests.toString());
+        ctx.headers.set("X-RateLimit-Remaining", (maxRequests - entry.count).toString());
+        ctx.headers.set("X-RateLimit-Reset", entry.resetTime.toString());
         return await next();
     };
 };

package/middleware/request-id.d.ts

@@ -14,4 +14,4 @@ import { Middleware } from "../types/index.js";
  * ```
  */
 declare const requestID: (headerName?: string, contextKey?: string) => Middleware;
-export { requestID, requestID as default };
+export { requestID as default, requestID };

package/middleware/request-id.js

@@ -1,13 +1,10 @@
 import { generateUUID } from "../helper/index.js";
 const requestID = (headerName = "X-Request-ID", contextKey = "requestID") => {
     return function requestID(ctx, next) {
-        let requestId = ctx.header(headerName);
-        if (!requestId) {
-            requestId = `req-${generateUUID()}`;
-        }
+        let requestId = ctx.headers.get(headerName) ?? `req-${generateUUID()}`;
         ctx[contextKey] = requestId;
-        ctx.setHeader(headerName, requestId);
+        ctx.headers.set(headerName, requestId);
         return next();
     };
 };
-export { requestID, requestID as default };
+export { requestID as default, requestID };