tezx 1.0.13 → 1.0.15

package/dist/header.d.ts

@@ -1,71 +0,0 @@
-export declare class HeadersParser {
-    private headers;
-    constructor(init?: [string, string | string[]][] | Record<string, string>);
-    /**
-     * Adds multiple headers to the parser.
-     * @param headers - Headers as an array of tuples or a record object.
-     */
-    add(headers: [string, string | string[]][] | Record<string, string>): this;
-    /**
-     * Sets a header value.
-     * @param key - Header name.
-     * @param value - Header value(s).
-     */
-    set(key: string, value: string | string[]): this;
-    clear(): this;
-    /**
-     * Retrieves the first value of a header.
-     * @param key - Header name.
-     * @returns The first header value or undefined if not found.
-     */
-    get(key: string): string | undefined;
-    /**
-     * Retrieves all values of a header.
-     * @param key - Header name.
-     * @returns An array of header values.
-     */
-    getAll(key: string): string[];
-    /**
-     * Checks if a header exists.
-     * @param key - Header name.
-     * @returns True if the header exists, false otherwise.
-     */
-    has(key: string): boolean;
-    /**
-     * Deletes a header.
-     * @param key - Header name.
-     * @returns True if deleted successfully, false otherwise.
-     */
-    delete(key: string): boolean;
-    /**
-     * Appends a value to an existing header or creates a new one.
-     * @param key - Header name.
-     * @param value - Value to append.
-     */
-    append(key: string, value: string): this;
-    /**
-     * Returns an iterator over header entries.
-     * @returns IterableIterator of header key-value pairs.
-     */
-    entries(): IterableIterator<[string, string[]]>;
-    /**
-     * Returns an iterator over header keys.
-     * @returns IterableIterator of header names.
-     */
-    keys(): IterableIterator<string>;
-    /**
-     * Returns an iterator over header values.
-     * @returns IterableIterator of header values arrays.
-     */
-    values(): IterableIterator<string[]>;
-    /**
-     * Iterates over headers and executes a callback function.
-     * @param callback - Function to execute for each header.
-     */
-    forEach(callback: (value: string[], key: string) => void): void;
-    /**
-     * Converts headers into a plain object.
-     * @returns A record of headers where single-value headers are returned as a string.
-     */
-    toObject(): Record<string, string | string[]>;
-}

package/dist/header.js

@@ -1,81 +0,0 @@
-export class HeadersParser {
-    headers = new Map();
-    constructor(init) {
-        if (init) {
-            this.add(init);
-        }
-    }
-    add(headers) {
-        if (Array.isArray(headers)) {
-            for (const [key, value] of headers) {
-                this.set(key, value);
-            }
-        }
-        else if (typeof Headers !== "undefined" && headers instanceof Headers) {
-            for (const [key, value] of headers.entries()) {
-                this.set(key, value);
-            }
-        }
-        else if (typeof headers === "object") {
-            for (const key in headers) {
-                if (Object.prototype.hasOwnProperty.call(headers, key)) {
-                    this.set(key, headers[key]);
-                }
-            }
-        }
-        return this;
-    }
-    set(key, value) {
-        this.headers.set(key.toLowerCase(), Array.isArray(value) ? value : [value]);
-        return this;
-    }
-    clear() {
-        this.headers.clear();
-        return this;
-    }
-    get(key) {
-        const values = this.headers.get(key.toLowerCase());
-        return values ? values[0] : undefined;
-    }
-    getAll(key) {
-        return this.headers.get(key.toLowerCase()) || [];
-    }
-    has(key) {
-        return this.headers.has(key.toLowerCase());
-    }
-    delete(key) {
-        return this.headers.delete(key.toLowerCase());
-    }
-    append(key, value) {
-        const lowerKey = key.toLowerCase();
-        if (this.headers.has(lowerKey)) {
-            this.headers.get(lowerKey).push(value);
-        }
-        else {
-            this.headers.set(lowerKey, [value]);
-        }
-        return this;
-    }
-    entries() {
-        return this.headers.entries();
-    }
-    keys() {
-        return this.headers.keys();
-    }
-    values() {
-        return this.headers.values();
-    }
-    forEach(callback) {
-        for (const [key, value] of this.headers) {
-            callback(value, key);
-        }
-    }
-    toObject() {
-        const obj = {};
-        for (const [key, value] of this.headers.entries()) {
-            obj[key] = value.length > 1 ? value : value[0];
-        }
-        return obj;
-    }
-}
-Object.defineProperty(HeadersParser, "name", { value: "Headers" });

package/dist/helper/common.d.ts

@@ -1,5 +0,0 @@
-/**
- * Generate a unique request ID
- * @returns {string} - A unique request identifier
- */
-export declare function generateID(): string;

package/dist/helper/common.js

@@ -1,8 +0,0 @@
-export function generateID() {
-    const timestamp = Date.now().toString(16);
-    const random = Math.floor(Math.random() * 0xffffffffffff)
-        .toString(16)
-        .padStart(12, "0");
-    const pid = (process.pid % 0x10000).toString(16).padStart(4, "0");
-    return `${timestamp}-${random}-${pid}`;
-}

package/dist/helper/env-parser.d.ts

@@ -1,5 +0,0 @@
-/**
- * Loads environment variables from .env files.
- * @param basePath - The base directory where .env files are located.
- */
-export declare function loadEnv(basePath?: string): Record<string, string>;

package/dist/helper/env-parser.js

@@ -1,66 +0,0 @@
-import { EnvironmentDetector } from "../environment";
-function parseEnvFile(filePath, result) {
-    try {
-        let fileExists = false;
-        let runtime = EnvironmentDetector.getEnvironment;
-        if (runtime === "node" || runtime === "bun") {
-            const { existsSync } = require("fs");
-            fileExists = existsSync(filePath);
-        }
-        else if (runtime === "deno") {
-            try {
-                Deno.statSync(filePath);
-                fileExists = true;
-            }
-            catch {
-                fileExists = false;
-            }
-        }
-        if (!fileExists) {
-            return;
-        }
-        let fileContent = "";
-        if (runtime === "node" || runtime === "bun") {
-            const { readFileSync } = require("fs");
-            fileContent = readFileSync(filePath, "utf8");
-        }
-        else if (runtime === "deno") {
-            fileContent = new TextDecoder("utf-8").decode(Deno.readFileSync(filePath));
-        }
-        const lines = fileContent.split("\n");
-        for (const line of lines) {
-            const trimmedLine = line.trim();
-            if (!trimmedLine || trimmedLine.startsWith("#"))
-                continue;
-            const [key, value] = trimmedLine.split("=", 2).map((part) => part.trim());
-            if (key && value) {
-                const parsedValue = value
-                    .replace(/^"(.*)"$/, "$1")
-                    .replace(/^'(.*)'$/, "$1");
-                result[key] = parsedValue;
-                if (runtime === "node" || runtime === "bun") {
-                    process.env[key] = parsedValue;
-                }
-                else if (runtime === "deno") {
-                    Deno.env.set(key, parsedValue);
-                }
-            }
-        }
-    }
-    catch (error) {
-        console.error(`[dotenv] Error parsing file: ${filePath}`, error);
-    }
-}
-export function loadEnv(basePath = "./") {
-    const result = {};
-    const envFiles = [
-        ".env",
-        ".env.local",
-        `.env.${process?.env?.NODE_ENV || "development"}`,
-        `.env.${process?.env?.NODE_ENV || "development"}.local`,
-    ];
-    for (const envFile of envFiles) {
-        parseEnvFile(`${basePath}${envFile}`, result);
-    }
-    return result;
-}

package/dist/helper/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./common";
-export { loadEnv } from "./env-parser";

package/dist/helper/index.js

@@ -1,2 +0,0 @@
-export * from "./common";
-export { loadEnv } from "./env-parser";

package/dist/middleware/cors.d.ts

@@ -1,10 +0,0 @@
-import { ctx as Context } from "../router";
-export type CorsOptions = {
-    origin?: string | RegExp | (string | RegExp)[] | ((reqOrigin: string) => boolean);
-    methods?: string[];
-    allowedHeaders?: string[];
-    exposedHeaders?: string[];
-    credentials?: boolean;
-    maxAge?: number;
-};
-export declare function cors(option?: CorsOptions): (ctx: Context, next: () => Promise<any>) => Promise<any>;

package/dist/middleware/cors.js

@@ -1,46 +0,0 @@
-export function cors(option = {}) {
-    const { methods, allowedHeaders, credentials, exposedHeaders, maxAge, origin, } = option;
-    return async (ctx, next) => {
-        const reqOrigin = ctx.req.headers.get("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 : "";
-        }
-        else if (typeof origin === "function") {
-            allowOrigin = origin(reqOrigin) ? reqOrigin : "";
-        }
-        ctx.headers.set("Access-Control-Allow-Origin", allowOrigin);
-        ctx.headers.set("Access-Control-Allow-Methods", (methods || ["GET", "POST", "PUT", "DELETE"]).join(", "));
-        ctx.headers.set("Access-Control-Allow-Headers", (allowedHeaders || ["Content-Type", "Authorization"]).join(", "));
-        if (exposedHeaders) {
-            ctx.headers.set("Access-Control-Expose-Headers", exposedHeaders.join(", "));
-        }
-        if (credentials) {
-            ctx.headers.set("Access-Control-Allow-Credentials", "true");
-        }
-        if (maxAge) {
-            ctx.headers.set("Access-Control-Max-Age", maxAge.toString());
-        }
-        if (ctx.req.method === "OPTIONS") {
-            return new Response(null, {
-                status: 204,
-                headers: ctx.headers.toObject(),
-            });
-        }
-        return await next();
-    };
-}

package/dist/middleware/index.d.ts

@@ -1,9 +0,0 @@
-export { cors } from "./cors";
-export type { CorsOptions } from "./cors";
-export * from "./logger";
-export * from "./powered-by";
-export * from "./request-id";
-export * from "./secureHeaders";
-export * from "./xssProtection";
-export * from "./sanitizeHeader";
-export * from "./rateLimiter";

package/dist/middleware/index.js

@@ -1,8 +0,0 @@
-export { cors } from "./cors";
-export * from "./logger";
-export * from "./powered-by";
-export * from "./request-id";
-export * from "./secureHeaders";
-export * from "./xssProtection";
-export * from "./sanitizeHeader";
-export * from "./rateLimiter";

package/dist/middleware/logger.d.ts

@@ -1,15 +0,0 @@
-import { Middleware } from "../router";
-/**
- * Logger Middleware
- * Logs incoming requests with method, pathname, status, and execution time.
- *
- * @returns {Middleware} - A middleware function for logging HTTP requests.
- *
- * @example
- * ```ts
- * import { logger } from 'tezx';
- *
- * app.use(logger());
- * ```
- */
-export declare function logger(): Middleware;

package/dist/middleware/logger.js

@@ -1,18 +0,0 @@
-import { COLORS } from "../utils/colors";
-export function logger() {
-    return async (ctx, next) => {
-        try {
-            console.log(`${COLORS.bold}<-- ${COLORS.reset}${COLORS.bgMagenta} ${ctx.method} ${COLORS.reset} ${ctx.pathname}`);
-            const startTime = performance.now();
-            let n = await next();
-            const elapsed = performance.now() - startTime;
-            console.log(`${COLORS.bold}--> ${COLORS.reset}${COLORS.bgBlue} ${ctx.method} ${COLORS.reset} ${ctx.pathname} ` +
-                `${COLORS.yellow}${ctx.getStatus}${COLORS.reset} ${COLORS.magenta}${elapsed.toFixed(2)}ms${COLORS.reset}`);
-            return n;
-        }
-        catch (err) {
-            console.error(`${COLORS.red}Error:${COLORS.reset}`, err.stack);
-            throw new Error(err.stack);
-        }
-    };
-}

package/dist/middleware/powered-by.d.ts

@@ -1,16 +0,0 @@
-import { Middleware } from "../router";
-/**
- * PoweredBy Middleware
- * Adds an "X-Powered-By" header to responses.
- *
- * @param {string} [serverName] - Optional custom server name; defaults to "TezX".
- * @returns {Middleware} - A middleware function for setting the "X-Powered-By" header.
- *
- * @example
- * ```ts
- * import { poweredBy } from 'tezx';
- *
- * app.use(poweredBy("MyServer"));
- * ```
- */
-export declare const poweredBy: (serverName?: string) => Middleware;

package/dist/middleware/powered-by.js

@@ -1,6 +0,0 @@
-export const poweredBy = (serverName) => {
-    return (ctx, next) => {
-        ctx.header("X-Powered-By", serverName || "TezX");
-        return next();
-    };
-};

package/dist/middleware/rateLimiter.d.ts

@@ -1,61 +0,0 @@
-import { Context } from "../context";
-import { Middleware } from "../router";
-export type RateLimiterOptions = {
-    /**
-     * 🔴 Maximum allowed requests in the time window
-     * @example
-     * maxRequests: 100 // Allow 100 requests per window
-     */
-    maxRequests: number;
-    /**
-     * 🕒 Time window in milliseconds
-     * @example
-     * windowMs: 60_000 // 1 minute window
-     */
-    windowMs: number;
-    /**
-     * 🔑 Client identifier generator function
-     * @default (ctx) => `${ctx.req.remoteAddress.address}:${ctx.req.remoteAddress.port}`
-     * @example
-     * 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 rate limit exceeded handler
-     * @default Sends 429 status with Retry-After header
-     * @example
-     * onError: (ctx, retryAfter) => {
-     *   ctx.status = 429;
-     *   ctx.body = { error: `Try again in ${retryAfter} seconds` };
-     * }
-     */
-    onError?: (ctx: Context, retryAfter: number, error: Error) => void;
-};
-/**
- * 🚦 Rate limiting middleware for request throttling
- *
- * Enforces maximum request limits per client with sliding window.
- * Currently supports in-memory storage only (Redis coming soon).
- *
- * @param {RateLimiterOptions} options - Configuration
- * @returns {Middleware} Middleware function
- *
- * @example
- * // Basic rate limiting (100 requests/minute)
- * app.use(rateLimiter({
- *   maxRequests: 100,
- *   windowMs: 60_000
- * }));
- *
- * // Custom client identification
- * app.use(rateLimiter({
- *   maxRequests: 10,
- *   windowMs: 10_000,
- *   keyGenerator: (ctx) => ctx.user?.id || ctx.ip
- * }));
- */
-export declare const rateLimiter: (options: RateLimiterOptions) => Middleware;

package/dist/middleware/rateLimiter.js

@@ -1,36 +0,0 @@
-export const rateLimiter = (options) => {
-    const { maxRequests, windowMs, keyGenerator = (ctx) => `${ctx.req.remoteAddress.address}:${ctx.req.remoteAddress.port}`, onError = (ctx, retryAfter, error) => {
-        ctx.setStatus = 429;
-        throw new Error(`Rate limit exceeded. Try again in ${retryAfter} seconds.`);
-    }, } = options;
-    const memoryStore = new Map();
-    return async (ctx, next) => {
-        const key = keyGenerator(ctx);
-        let requestCount;
-        let resetTime;
-        for (const [key, entry] of memoryStore.entries()) {
-            if (Date.now() >= entry.resetTime) {
-                memoryStore.delete(key);
-            }
-        }
-        const entry = memoryStore.get(key);
-        if (entry && Date.now() < entry.resetTime) {
-            requestCount = entry.count + 1;
-            resetTime = entry.resetTime;
-        }
-        else {
-            requestCount = 1;
-            resetTime = Date.now() + windowMs;
-            memoryStore.set(key, { count: requestCount, resetTime });
-        }
-        if (requestCount > maxRequests) {
-            const retryAfter = Math.ceil((resetTime - Date.now()) / 1000);
-            ctx.headers.set("Retry-After", retryAfter.toString());
-            return onError(ctx, retryAfter, new Error(`Rate limit exceeded. Retry after ${retryAfter} seconds.`));
-        }
-        ctx.headers.set("X-RateLimit-Limit", maxRequests.toString());
-        ctx.headers.set("X-RateLimit-Remaining", (maxRequests - requestCount).toString());
-        ctx.headers.set("X-RateLimit-Reset", resetTime.toString());
-        return await next();
-    };
-};

package/dist/middleware/request-id.d.ts

@@ -1,16 +0,0 @@
-import { Middleware } from "../router";
-/**
- * Request ID Middleware
- * Assigns a unique request ID to each incoming request.
- *
- * @param {string} [headerName="X-Request-ID"] - Header name to use for request ID.
- * @returns {Middleware} - A middleware function for tracking requests.
- *
- * @example
- * ```ts
- * import { requestID } from 'tezx';
- *
- * app.use(requestID());
- * ```
- */
-export declare const requestID: (headerName?: string) => Middleware;

package/dist/middleware/request-id.js

@@ -1,11 +0,0 @@
-import { generateID } from "../helper";
-export const requestID = (headerName = "X-Request-ID") => {
-    return (ctx, next) => {
-        const existingID = ctx.headers?.get(headerName.toLowerCase()) ||
-            ctx.headers?.get(headerName);
-        const requestId = existingID || `req-${generateID()}`;
-        ctx.state.set("requestID", requestId);
-        ctx.header(headerName, requestId);
-        return next();
-    };
-};

package/dist/middleware/sanitizeHeader.d.ts

@@ -1,53 +0,0 @@
-import { Middleware } from "../router";
-type SanitizeHeadersOptions = {
-    /**
-     * 🟢 Whitelist of allowed headers (case-insensitive)
-     * @default [] (allow all if empty)
-     * @example
-     * whitelist: ['content-type', 'authorization'] // Only allow these headers
-     */
-    whitelist?: string[];
-    /**
-     * 🔴 Blacklist of disallowed headers (case-insensitive)
-     * @default [] (block none if empty)
-     * @example
-     * blacklist: ['x-powered-by', 'server'] // Block server info headers
-     */
-    blacklist?: string[];
-    /**
-     * 🔵 Normalize header keys to lowercase
-     * @default true
-     * @example
-     * normalizeKeys: false // Preserve original header case
-     */
-    normalizeKeys?: boolean;
-    /**
-     * 🟠 Allow potentially unsafe characters in header values
-     * @default false
-     * @warning Enabling this may reduce security
-     * @example
-     * allowUnsafeCharacters: true // Allow CR/LF in headers
-     */
-    allowUnsafeCharacters?: boolean;
-};
-/**
- * 🧼 Middleware to sanitize HTTP headers for security and compliance
- *
- * Removes dangerous headers, enforces allow/block lists, and normalizes headers.
- * Protects against header injection and information leakage.
- *
- * @param {SanitizeHeadersOptions} [options={}] - Configuration options
- * @returns {Middleware} Middleware function
- *
- * @example
- * // Basic usage with defaults
- * app.use(sanitizeHeaders());
- *
- * // Strict configuration
- * app.use(sanitizeHeaders({
- *   whitelist: ['accept', 'content-type'],
- *   normalizeKeys: true
- * }));
- */
-export declare const sanitizeHeaders: (options?: SanitizeHeadersOptions) => Middleware;
-export {};

package/dist/middleware/sanitizeHeader.js

@@ -1,47 +0,0 @@
-import { GlobalConfig } from "../config/config";
-export const sanitizeHeaders = (options = {}) => {
-    const { whitelist = [], blacklist = [], normalizeKeys = true, allowUnsafeCharacters = false, } = options;
-    return async (ctx, next) => {
-        const sanitizedHeaders = new Map();
-        for (const [key, values] of ctx.headers.entries()) {
-            if (!Array.isArray(values) || values.length === 0) {
-                continue;
-            }
-            const normalizedKey = normalizeKeys ? key.toLowerCase() : key;
-            if (whitelist.length > 0 &&
-                !whitelist.some((r) => r?.toLowerCase() === normalizedKey)) {
-                GlobalConfig.debugging.warn(`🚫 Header "${normalizedKey}" not in whitelist - removed`);
-                continue;
-            }
-            if (blacklist.some((r) => r.toLowerCase() === normalizedKey)) {
-                GlobalConfig.debugging.warn(`🚫 Header "${normalizedKey}" in blacklist - removed`);
-                continue;
-            }
-            if (!isValidHeaderName(normalizedKey)) {
-                GlobalConfig.debugging.warn(`⚠️ Invalid header name: "${normalizedKey}" - removed`);
-                continue;
-            }
-            const sanitizedValues = values
-                .map((value) => sanitizeHeaderValue(value, allowUnsafeCharacters))
-                .filter(Boolean);
-            if (sanitizedValues.length === 0) {
-                GlobalConfig.debugging.warn(`⚠️ All values for "${normalizedKey}" invalid - removed`);
-                continue;
-            }
-            sanitizedHeaders.set(normalizedKey, sanitizedValues);
-        }
-        ctx.headers.clear().add([...sanitizedHeaders.entries()]);
-        return await next();
-    };
-};
-const isValidHeaderName = (name) => {
-    const HEADER_NAME_REGEX = /^[a-zA-Z0-9\-_]+$/;
-    return HEADER_NAME_REGEX.test(name);
-};
-const sanitizeHeaderValue = (value, allowUnsafeCharacters) => {
-    let sanitized = value.trim();
-    if (!allowUnsafeCharacters) {
-        sanitized = sanitized.replace(/[\x00-\x1F\x7F]/g, "");
-    }
-    return sanitized;
-};