tezx 2.0.11 → 3.0.0

package/helper/index.js

@@ -1,13 +1,33 @@
 import { GlobalConfig } from "../core/config.js";
-import { Environment } from "../core/environment.js";
 import { colorText } from "../utils/colors.js";
-import { sanitizePathSplit } from "../utils/url.js";
-import { generateID } from "./common.js";
-export { colorText, Environment, generateID, GlobalConfig, sanitizePathSplit };
+import { allCookies, deleteCookie, getCookie, setCookie, } from "../utils/cookie.js";
+import { fileExists, fileSize, getFileBuffer, readStream, } from "../utils/file.js";
+import { useFormData } from "../utils/formData.js";
+import { generateID, generateRandomBase64, generateUUID, } from "../utils/generateID.js";
+import { httpStatusMap } from "../utils/httpStatusMap.js";
+import { extensionExtract, normalizeHeaderKey, sanitizePathSplit, sanitizePathSplitBasePath, sanitized, } from "../utils/low-level.js";
+import { runtime } from "../utils/runtime.js";
+export { GlobalConfig, allCookies, colorText, deleteCookie, extensionExtract, fileExists, fileSize, generateID, generateRandomBase64, generateUUID, getCookie, getFileBuffer, httpStatusMap, normalizeHeaderKey, readStream, runtime, sanitizePathSplit, sanitizePathSplitBasePath, sanitized, setCookie, useFormData, };
 export default {
-    Environment,
-    colorText,
-    GlobalConfig,
+    useFormData,
+    generateRandomBase64,
+    runtime,
+    extensionExtract,
+    normalizeHeaderKey,
     sanitizePathSplit,
+    sanitizePathSplitBasePath,
+    sanitized,
+    allCookies,
+    deleteCookie,
+    getCookie,
+    setCookie,
+    fileExists,
+    fileSize,
+    getFileBuffer,
+    readStream,
     generateID,
+    generateUUID,
+    httpStatusMap,
+    colorText,
+    GlobalConfig,
 };

package/index.d.ts

@@ -1,18 +1,20 @@
+import { TezXError } from "./core/error.js";
 import { Router } from "./core/router.js";
-import { TezX } from "./core/server.js";
-import { compileRegexRoute, regexMatchRoute } from "./utils/regexRouter.js";
+import { TezX, TezX as TezXBase } from "./core/server.js";
 export type { Context as BaseContext } from "./core/context.js";
+export type { NetAddr as AddressType, Callback, Ctx as Context, CookieOptions, ErrorHandler, FormDataOptions, HandlerType, HttpBaseResponse, HTTPMethod, Middleware, NextCallback, ReqHeaderKey, RequestHeaders, ResHeaderKey, ResponseHeaders, ResponseInit, RouteMatchResult, RouteRegistry, Runtime, ServeStatic, StaticFileArray, StaticServeOption, WebSocketCallback, WebSocketEvent, WebSocketOptions, } from "./types/index.js";
+export type { TezXConfig } from "./core/server.js";
+export type { TezXRequest } from "./core/request.js";
 export type { RouterConfig } from "./core/router.js";
-export type { AdapterType, NetAddr as AddressType, Callback, CallbackReturn, ConnAddress, ctx as Context, CookieOptions, FormDataOptions, HTTPMethod, Middleware, NextCallback, PathType, ResponseHeaders, StaticServeOption } from "./types/index.js";
-export type { TezXConfig, TezXServeOptions } from "./core/server.js";
-export type { UrlRef } from "./utils/url.js";
-export { compileRegexRoute, regexMatchRoute, Router, TezX };
+export { Router, TezX, TezXError };
 export declare let version: string;
 declare const _default: {
     Router: typeof Router;
-    regexMatchRoute: typeof regexMatchRoute;
-    compileRegexRoute: typeof compileRegexRoute;
     TezX: typeof TezX;
     version: string;
+    TezXError: typeof TezXError;
 };
 export default _default;
+declare global {
+    var TezX: typeof TezXBase;
+}

package/index.js

@@ -1,12 +1,11 @@
+import { TezXError } from "./core/error.js";
 import { Router } from "./core/router.js";
 import { TezX } from "./core/server.js";
-import { compileRegexRoute, regexMatchRoute } from "./utils/regexRouter.js";
-export { compileRegexRoute, regexMatchRoute, Router, TezX };
-export let version = "2.0.11";
+export { Router, TezX, TezXError };
+export let version = "3.0.0";
 export default {
     Router,
-    regexMatchRoute,
-    compileRegexRoute,
     TezX,
     version,
+    TezXError,
 };

package/jwt/node.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Generates a signed JSON Web Token (JWT).
+ *
+ * @function sign
+ * @param {Record<string, any>} payload - The payload object containing user data or claims.
+ * @param {Object} [options] - Optional signing options.
+ * @param {string} [options.secret] - The secret key used to sign the token (default: process.env.JWT_SECRET or "tezx_secret").
+ * @param {"HS256" | "HS512"} [options.algorithm="HS256"] - Hash algorithm to use (HMAC SHA-256 or SHA-512).
+ * @param {string | number} [options.expiresIn="1d"] - Token expiration time (e.g., "2h", "7d", 3600).
+ * @returns {string} The generated JWT as a string in the format `header.payload.signature`.
+ *
+ * @example
+ * const token = sign({ userId: 1 }, { secret: "mySecret", algorithm: "HS512", expiresIn: "2h" });
+ * console.log(token);
+ */
+export declare function sign(payload: Record<string, any>, options?: {
+    secret?: string;
+    algorithm?: "HS256" | "HS512";
+    expiresIn?: string | number;
+}): string;
+/**
+ * Verifies and decodes a JSON Web Token (JWT).
+ *
+ * @function verify
+ * @param {string} token - The JWT string to verify.
+ * @param {string} [secret] - The secret key used to verify the token (default: process.env.JWT_SECRET or "tezx_secret").
+ * @returns {Record<string, any> | null} Decoded payload if valid; otherwise `null`.
+ *
+ * @example
+ * const decoded = verify(token, "mySecret");
+ * if (decoded) console.log("User ID:", decoded.userId);
+ * else console.log("Invalid or expired token");
+ */
+export declare function verify(token: string, secret?: string): Record<string, any> | null;
+declare const _default: {
+    verify: typeof verify;
+    sign: typeof sign;
+};
+export default _default;

package/jwt/node.js

@@ -0,0 +1,87 @@
+import { Buffer } from "node:buffer";
+import crypto from "node:crypto";
+function base64url(input) {
+    return Buffer.from(input)
+        .toString("base64")
+        .replace(/=/g, "")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_");
+}
+function parseExpiry(exp) {
+    const match = exp.match(/^(\d+)([smhd])$/);
+    if (!match)
+        return parseInt(exp, 10);
+    const [, val, unit] = match;
+    const num = parseInt(val, 10);
+    switch (unit) {
+        case "s":
+            return num;
+        case "m":
+            return num * 60;
+        case "h":
+            return num * 3600;
+        case "d":
+            return num * 86400;
+        default:
+            return num;
+    }
+}
+function base64urlDecode(input) {
+    input = input.replace(/-/g, "+").replace(/_/g, "/");
+    const pad = input.length % 4;
+    if (pad)
+        input += "=".repeat(4 - pad);
+    return Buffer.from(input, "base64").toString("utf8");
+}
+export function sign(payload, options) {
+    const header = {
+        alg: options?.algorithm || "HS256",
+        typ: "JWT",
+    };
+    const now = Math.floor(Date.now() / 1000);
+    const exp = typeof options?.expiresIn === "string"
+        ? now + parseExpiry(options.expiresIn)
+        : typeof options?.expiresIn === "number"
+            ? now + options.expiresIn
+            : now + 86400;
+    const fullPayload = { ...payload, iat: now, exp };
+    const encodedHeader = base64url(JSON.stringify(header));
+    const encodedPayload = base64url(JSON.stringify(fullPayload));
+    const data = `${encodedHeader}.${encodedPayload}`;
+    const secret = options?.secret || process.env.JWT_SECRET || "tezx_secret";
+    const signature = crypto
+        .createHmac(header.alg === "HS512" ? "sha512" : "sha256", secret)
+        .update(data)
+        .digest("base64")
+        .replace(/=/g, "")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_");
+    return `${data}.${signature}`;
+}
+export function verify(token, secret) {
+    try {
+        const [encodedHeader, encodedPayload, signature] = token.split(".");
+        const data = `${encodedHeader}.${encodedPayload}`;
+        const decodedHeader = JSON.parse(base64urlDecode(encodedHeader));
+        const expectedSig = crypto
+            .createHmac(decodedHeader.alg === "HS512" ? "sha512" : "sha256", secret || process.env.JWT_SECRET || "tezx_secret")
+            .update(data)
+            .digest("base64")
+            .replace(/=/g, "")
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_");
+        if (expectedSig !== signature)
+            return null;
+        const payload = JSON.parse(base64urlDecode(encodedPayload));
+        if (payload.exp && Date.now() / 1000 > payload.exp)
+            return null;
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+export default {
+    verify,
+    sign,
+};

package/jwt/web.d.ts

@@ -0,0 +1,14 @@
+type Alg = "HS256" | "HS512";
+/** Sign payload and return JWT (async) */
+export declare function sign(payload: Record<string, any>, opts?: {
+    secret?: string;
+    algorithm?: Alg;
+    expiresIn?: string | number;
+}): Promise<string>;
+/** Verify JWT, return payload or null */
+export declare function verify(token: string, secret?: string): Promise<Record<string, any> | null>;
+declare const _default: {
+    sign: typeof sign;
+    verify: typeof verify;
+};
+export default _default;

package/jwt/web.js

@@ -0,0 +1,174 @@
+function parseExpiry(exp) {
+    const match = exp.match(/^(\d+)([smhd])$/);
+    if (!match)
+        return parseInt(exp, 10);
+    const [, val, unit] = match;
+    const num = parseInt(val, 10);
+    switch (unit) {
+        case "s":
+            return num;
+        case "m":
+            return num * 60;
+        case "h":
+            return num * 3600;
+        case "d":
+            return num * 86400;
+        default:
+            return num;
+    }
+}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+function uint8ToBase64(u8) {
+    let binary = "";
+    const len = u8.length;
+    for (let i = 0; i < len; i++)
+        binary += String.fromCharCode(u8[i]);
+    return typeof btoa !== "undefined" ? btoa(binary) : fallbackBtoa(binary);
+}
+function base64ToUint8(base64) {
+    const bin = typeof atob !== "undefined" ? atob(base64) : fallbackAtob(base64);
+    const len = bin.length;
+    const u8 = new Uint8Array(len);
+    for (let i = 0; i < len; i++)
+        u8[i] = bin.charCodeAt(i);
+    return u8;
+}
+function base64urlFromUint8(u8) {
+    return uint8ToBase64(u8)
+        .replace(/=/g, "")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_");
+}
+function base64urlEncodeString(str) {
+    return base64urlFromUint8(encoder.encode(str));
+}
+function base64urlDecodeToString(input) {
+    let b64 = input.replace(/-/g, "+").replace(/_/g, "/");
+    const pad = b64.length % 4;
+    if (pad)
+        b64 += "=".repeat(4 - pad);
+    const u8 = base64ToUint8(b64);
+    return decoder.decode(u8);
+}
+function constantTimeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let res = 0;
+    for (let i = 0; i < a.length; i++) {
+        res |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return res === 0;
+}
+function mapAlg(alg) {
+    if (alg === "HS256")
+        return { name: "HMAC", hash: "SHA-256" };
+    return { name: "HMAC", hash: "SHA-512" };
+}
+async function importKey(secret, alg) {
+    const keyData = encoder.encode(secret);
+    return crypto.subtle.importKey("raw", keyData, mapAlg(alg), false, [
+        "sign",
+        "verify",
+    ]);
+}
+async function hmacSign(key, data) {
+    const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(data));
+    return new Uint8Array(sig);
+}
+function fallbackBtoa(binaryStr) {
+    let base64 = "";
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let i = 0;
+    const len = binaryStr.length;
+    while (i < len) {
+        const c1 = binaryStr.charCodeAt(i++) & 0xff;
+        if (i === len) {
+            base64 += chars.charAt(c1 >> 2);
+            base64 += chars.charAt((c1 & 0x3) << 4);
+            base64 += "==";
+            break;
+        }
+        const c2 = binaryStr.charCodeAt(i++);
+        if (i === len) {
+            base64 += chars.charAt(c1 >> 2);
+            base64 += chars.charAt(((c1 & 0x3) << 4) | ((c2 & 0xf0) >> 4));
+            base64 += chars.charAt((c2 & 0xf) << 2);
+            base64 += "=";
+            break;
+        }
+        const c3 = binaryStr.charCodeAt(i++);
+        base64 += chars.charAt(c1 >> 2);
+        base64 += chars.charAt(((c1 & 0x3) << 4) | ((c2 & 0xf0) >> 4));
+        base64 += chars.charAt(((c2 & 0xf) << 2) | ((c3 & 0xc0) >> 6));
+        base64 += chars.charAt(c3 & 0x3f);
+    }
+    return base64;
+}
+function fallbackAtob(b64) {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let output = "";
+    let i = 0;
+    b64 = b64.replace(/[^A-Za-z0-9\+\/]/g, "");
+    while (i < b64.length) {
+        const enc1 = chars.indexOf(b64.charAt(i++));
+        const enc2 = chars.indexOf(b64.charAt(i++));
+        const enc3 = chars.indexOf(b64.charAt(i++));
+        const enc4 = chars.indexOf(b64.charAt(i++));
+        const chr1 = (enc1 << 2) | (enc2 >> 4);
+        const chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+        const chr3 = ((enc3 & 3) << 6) | enc4;
+        output += String.fromCharCode(chr1);
+        if (enc3 !== 64 && enc3 !== -1)
+            output += String.fromCharCode(chr2);
+        if (enc4 !== 64 && enc4 !== -1)
+            output += String.fromCharCode(chr3);
+    }
+    return output;
+}
+export async function sign(payload, opts) {
+    const alg = (opts?.algorithm || "HS256");
+    const secret = opts?.secret || globalThis.JWT_SECRET || "tezx_secret";
+    const header = { alg, typ: "JWT" };
+    const now = Math.floor(Date.now() / 1000);
+    const exp = typeof opts?.expiresIn === "string"
+        ? now + parseExpiry(opts.expiresIn)
+        : typeof opts?.expiresIn === "number"
+            ? now + opts.expiresIn
+            : now + 86400;
+    const fullPayload = { ...payload, iat: now, exp };
+    const encodedHeader = base64urlEncodeString(JSON.stringify(header));
+    const encodedPayload = base64urlEncodeString(JSON.stringify(fullPayload));
+    const data = `${encodedHeader}.${encodedPayload}`;
+    const key = await importKey(secret, alg);
+    const sigU8 = await hmacSign(key, data);
+    const signature = base64urlFromUint8(sigU8);
+    return `${data}.${signature}`;
+}
+export async function verify(token, secret) {
+    try {
+        const parts = token.split(".");
+        if (parts.length !== 3)
+            return null;
+        const [eh, ep, sig] = parts;
+        const data = `${eh}.${ep}`;
+        const headerJson = base64urlDecodeToString(eh);
+        const header = JSON.parse(headerJson);
+        const alg = header?.alg === "HS512" ? "HS512" : "HS256";
+        const s = secret || globalThis.JWT_SECRET || "tezx_secret";
+        const key = await importKey(s, alg);
+        const expectedSigU8 = await hmacSign(key, data);
+        const expectedSig = base64urlFromUint8(expectedSigU8);
+        if (!constantTimeEqual(expectedSig, sig))
+            return null;
+        const payloadJson = base64urlDecodeToString(ep);
+        const payload = JSON.parse(payloadJson);
+        if (payload.exp && Date.now() / 1000 > payload.exp)
+            return null;
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+export default { sign, verify };

package/middleware/basic-auth.d.ts

@@ -0,0 +1,56 @@
+import { Context } from "../core/context.js";
+import { TezXError } from "../core/error.js";
+import { HttpBaseResponse, Middleware } from "../types/index.js";
+/**
+ * Options for Basic Authentication middleware.
+ */
+export type BasicAuthOptions = {
+    /**
+     * 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 Whether the credentials are valid.
+     */
+    validate: (username: string, password: string, ctx: Context) => boolean | Promise<boolean>;
+    /**
+     * Realm name shown in the `WWW-Authenticate` header.
+     * Defaults to `"Restricted Area"`.
+     */
+    realm?: string;
+    /**
+     * Custom handler for unauthorized requests.
+     *
+     * @param ctx - The current request context.
+     * @param error - Optional error object describing why access was denied.
+     * @returns HttpBaseResponse to send to the client.
+     */
+    onUnauthorized?: (ctx: Context, error?: TezXError) => HttpBaseResponse;
+};
+/**
+ * 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",
+ * });
+ *
+ * app.use("/admin", auth, (ctx) => {
+ *   ctx.json({ message: "Access granted" });
+ * });
+ * ```
+ */
+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

@@ -0,0 +1,38 @@
+import { TezXError, TezXErrorParse } from "../core/error.js";
+import { base64Decode } from "../utils/buffer.js";
+export const basicAuth = (options) => {
+    const { validate, realm = "Restricted Area", onUnauthorized = (ctx, error) => {
+        ctx.setStatus = 401;
+        ctx.headers.set("WWW-Authenticate", `Basic realm="${realm}"`);
+        return ctx.json({ error: error?.message || "Unauthorized" });
+    }, } = options;
+    return async (ctx, next) => {
+        const auth = ctx.req.header("authorization");
+        if (!auth || !auth.startsWith("Basic ")) {
+            return onUnauthorized(ctx, new TezXError("Basic authentication required"));
+        }
+        const base64 = auth.slice(6).trim();
+        if (!base64) {
+            return onUnauthorized(ctx, new TezXError("Empty credentials"));
+        }
+        let username, password;
+        try {
+            const decoded = base64Decode(base64);
+            const idx = decoded.indexOf(":");
+            if (idx === -1)
+                throw new TezXError("Missing colon in credentials", 400);
+            username = decoded.slice(0, idx);
+            password = decoded.slice(idx + 1);
+            const valid = await validate(username, password, ctx);
+            if (!valid) {
+                return onUnauthorized(ctx, new TezXError("Invalid username or password", 403));
+            }
+            ctx.user = { username };
+            await next();
+        }
+        catch (err) {
+            return onUnauthorized(ctx, TezXErrorParse(err));
+        }
+    };
+};
+export default basicAuth;

package/middleware/bearer-auth.d.ts

@@ -0,0 +1,53 @@
+import { Context } from "../core/context.js";
+import { TezXError } from "../core/error.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?: TezXError) => 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 @@
+import { TezXError, TezXErrorParse } from "../core/error.js";
+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 TezXError("Bearer token required"));
+        }
+        const token = auth.slice(7).trim();
+        if (!token) {
+            return onUnauthorized(ctx, new TezXError("Empty token"));
+        }
+        try {
+            const valid = await validate(token, ctx);
+            if (!valid) {
+                return onUnauthorized(ctx, new TezXError("Invalid or expired token"));
+            }
+            ctx.token = token;
+            await next();
+        }
+        catch (err) {
+            return onUnauthorized(ctx, TezXErrorParse(err));
+        }
+    };
+};
+export default bearerAuth;

package/middleware/cache-control.d.ts

@@ -0,0 +1,30 @@
+import { Context } from "../core/context.js";
+import { TezXError } from "../core/error.js";
+import { HttpBaseResponse, Middleware } from "../types/index.js";
+export interface CacheRule {
+    /** 🎯 Condition to determine if this rule applies */
+    condition: (ctx: Context) => boolean;
+    /** ⏳ Max age (seconds) */
+    maxAge: number;
+    /** 🌐 Cache scope */
+    scope: "public" | "private";
+    /** 🏷️ Vary header list */
+    vary?: string[];
+}
+export interface CacheSettings extends Pick<CacheRule, "maxAge" | "scope" | "vary"> {
+}
+export interface CacheOptions {
+    /** 🧱 Default cache behavior */
+    defaultSettings: CacheSettings;
+    /** 🔧 Optional rules for dynamic caching */
+    rules?: readonly CacheRule[];
+    /** 📝 Logging hook */
+    /** 🚨 Error handler */
+    onError?: (error: TezXError, ctx: Context) => HttpBaseResponse;
+}
+/**
+ * ⚡ Ultra-lightweight, low-level cache control middleware.
+ * Adds 'Cache-Control', 'Expires', and optional 'Vary' headers.
+ */
+export declare const cacheControl: (opts: CacheOptions) => Middleware;
+export default cacheControl;

package/middleware/cache-control.js

@@ -0,0 +1,40 @@
+import { TezXErrorParse } from "../core/error.js";
+export const cacheControl = (opts) => {
+    const { defaultSettings, rules = [], onError = (err, ctx) => {
+        ctx.setStatus = 500;
+        ctx.body = { error: err.message ?? "Cache middleware failed" };
+    }, } = opts;
+    const len = rules.length | 0;
+    return async function cacheControlMiddleware(ctx, next) {
+        const method = ctx.method;
+        if (method !== "GET" && method !== "HEAD") {
+            return await next();
+        }
+        try {
+            await next();
+            let matched;
+            for (let i = 0; i < len; i++) {
+                const rule = rules[i];
+                if (rule.condition(ctx)) {
+                    matched = rule;
+                    break;
+                }
+            }
+            const settings = matched ?? defaultSettings;
+            const maxAge = settings.maxAge;
+            const scope = settings.scope;
+            const vary = settings.vary;
+            const cacheValue = `${scope}, max-age=${maxAge}`;
+            const expiresValue = new Date(Date.now() + maxAge * 1000).toUTCString();
+            const headers = ctx.headers;
+            headers.set("Cache-Control", cacheValue);
+            headers.set("Expires", expiresValue);
+            if (vary && vary.length > 0)
+                headers.set("Vary", vary.join(", "));
+        }
+        catch (err) {
+            return onError(TezXErrorParse(err), ctx);
+        }
+    };
+};
+export default cacheControl;