tezx 1.0.73 → 1.0.75-beta

package/core/request.d.ts

@@ -1,5 +1,4 @@
 import { UrlRef } from "../utils/url.js";
-import { HeadersParser } from "./header.js";
 import { TezXServeOptions } from "./server.js";
 export type FormDataOptions = {
     maxSize?: number;
@@ -20,7 +19,6 @@ export type ConnAddress = {
 };
 export type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "OPTIONS" | "PATCH" | "HEAD" | "ALL" | "TRACE" | "CONNECT" | string;
 export declare class Request {
-    #private;
     /**
      * Full request URL including protocol and query string
      * @type {string}
@@ -57,31 +55,21 @@ export declare class Request {
      * ```
      */
     remoteAddress: NetAddr;
-    constructor({ headers, params, req, options, urlRef, }: {
+    constructor({ params, method, req, options, }: {
+        method: string;
         req: any;
         params: Record<string, any>;
-        headers: HeadersParser;
-        urlRef: UrlRef;
         options: TezXServeOptions;
     });
     get headers(): {
         /**
          * Retrieves the first value of a specific header.
          * @param key - Header name to search for.
-         * @returns The first header value or undefined if not found.
+         * @returns The first header value or null if not found.
          * @example
          * get('content-type') // returns 'application/json'
          */
-        get: (key: string) => string | undefined;
-        /**
-         * Retrieves all values of a specific header.
-         * If multiple values exist for a header, all will be returned as an array.
-         * @param key - Header name to search for.
-         * @returns An array of all header values associated with the key.
-         * @example
-         * getAll('accept-language') // returns ['en-US', 'fr-CA']
-         */
-        getAll: (key: string) => string | never[];
+        get: (key: string) => string | null;
         /**
          * Checks if a header exists in the request.
          * @param key - Header name to check for existence.
@@ -93,13 +81,13 @@ export declare class Request {
         /**
          * Returns an iterator over all header entries.
          * Each entry is a [key, value] pair where the value can be an array of strings.
-         * @returns IterableIterator for iterating over header key-value pairs.
+         * @returns HeadersIterator for iterating over header key-value pairs.
          * @example
          * for (let [key, value] of headers.entries()) {
          *   console.log(key, value);
          * }
          */
-        entries: () => IterableIterator<[string, string[]]>;
+        entries: () => HeadersIterator<[string, string]>;
         /**
          * Returns an iterator over all header keys.
          * This allows iteration over the names of all headers in the request.
@@ -113,13 +101,13 @@ export declare class Request {
         /**
          * Returns an iterator over all header values.
          * This allows iteration over the values of all headers, with each value being an array of strings.
-         * @returns IterableIterator of header values.
+         * @returns HeadersIterator<string> of header values.
          * @example
          * for (let value of headers.values()) {
          *   console.log(value);
          * }
          */
-        values: () => IterableIterator<string[]>;
+        values: () => HeadersIterator<string>;
         /**
          * Iterates over each header and executes a callback for every header found.
          * @param callback - Function to execute for each header. Receives the value array and key.
@@ -128,34 +116,25 @@ export declare class Request {
          *   console.log(key, value);
          * });
          */
-        forEach: (callback: (value: string[], key: string) => void) => void;
+        forEach: (callbackfn: (value: string, key: string, parent: Headers) => void) => void;
         /**
          * Converts headers to a JSON-safe plain object (only single string values).
          * Multi-value headers are joined by commas.
          * @returns A record of headers with string values.
          */
         toJSON(): Record<string, string>;
-        /**
-         * Converts all headers into a plain JavaScript object.
-         * Single-value headers are represented as a string, and multi-value headers as an array.
-         * @returns A plain object with header names as keys and their values as strings or arrays.
-         * @example
-         * const headersObject = headers.toObject();
-         * console.log(headersObject);
-         */
-        toObject: () => Record<string, string | string[]>;
     };
     /**
      * Parses the request body as plain text.
      * @returns {Promise<string>} The text content of the request body.
      */
-    text(): Promise<string>;
+    text(): Promise<any>;
     /**
      * Parses the request body as JSON.
      * @returns {Promise<Record<string, any>>} The parsed JSON object.
      * If the Content-Type is not 'application/json', it returns an empty object.
      */
-    json(): Promise<Record<string, any>>;
+    json(): Promise<any>;
     /**
      * Parses the request body based on Content-Type.
      * Supports:

package/core/request.js

@@ -1,7 +1,6 @@
-import { parseJsonBody, parseMultipartBody, parseTextBody, parseUrlEncodedBody, } from "../utils/formData.js";
-import { HeadersParser } from "./header.js";
+import { sanitized } from "../utils/formData.js";
+import { urlParse } from "../utils/url.js";
 export class Request {
-    #headers = new HeadersParser();
     url;
     method;
     urlRef = {
@@ -17,25 +16,23 @@ export class Request {
     rawRequest;
     params = {};
     remoteAddress = {};
-    constructor({ headers, params, req, options, urlRef, }) {
+    constructor({ params, method, req, options, }) {
+        let parse = urlParse(req.url);
+        let url = parse?.href;
         this.remoteAddress = options?.connInfo?.remoteAddr;
-        this.#headers = headers;
-        this.url = urlRef.href || "";
-        this.urlRef = urlRef;
-        this.method = req?.method?.toUpperCase();
+        this.url = url || "";
+        this.urlRef = parse;
+        this.method = method;
         this.params = params;
         this.rawRequest = req;
-        this.query = urlRef.query;
+        this.query = parse.query;
     }
     get headers() {
-        let requestHeaders = this.#headers;
+        let requestHeaders = this.rawRequest.headers;
         return {
             get: function get(key) {
                 return requestHeaders.get(key.toLowerCase());
             },
-            getAll: function getAll(key) {
-                return requestHeaders.get(key.toLowerCase()) || [];
-            },
             has: function has(key) {
                 return requestHeaders.has(key.toLowerCase());
             },
@@ -48,47 +45,94 @@ export class Request {
             values: function values() {
                 return requestHeaders.values();
             },
-            forEach: function forEach(callback) {
-                return requestHeaders.forEach(callback);
+            forEach: function forEach(callbackfn) {
+                return requestHeaders.forEach(callbackfn);
             },
             toJSON() {
                 return requestHeaders.toJSON();
             },
-            toObject: function toObject() {
-                return requestHeaders.toObject();
-            },
         };
     }
     async text() {
-        return await parseTextBody(this.rawRequest);
+        return await this.rawRequest.text();
     }
     async json() {
-        const contentType = this.#headers.get("content-type") || "";
+        const contentType = this.rawRequest.headers.get("content-type") || "";
         if (contentType.includes("application/json")) {
-            return await parseJsonBody(this.rawRequest);
+            return await this.rawRequest.json();
         }
         else {
             return {};
         }
     }
     async formData(options) {
-        const contentType = this.#headers.get("content-type") || "";
+        const contentType = this.rawRequest.headers.get("content-type") || "";
         if (!contentType) {
             throw Error("Invalid Content-Type");
         }
         if (contentType.includes("application/json")) {
-            return await parseJsonBody(this.rawRequest);
+            return await this.rawRequest.json();
         }
         else if (contentType.includes("application/x-www-form-urlencoded")) {
-            return parseUrlEncodedBody(this.rawRequest);
+            const formData = await this.rawRequest.formData();
+            const result = {};
+            for (const [key, value] of formData.entries()) {
+                result[key] = value;
+            }
+            return result;
         }
         else if (contentType.includes("multipart/form-data")) {
             const boundaryMatch = contentType.match(/boundary=([^;]+)/);
             if (!boundaryMatch) {
                 throw new Error("Boundary not found in multipart/form-data");
             }
-            const boundary = boundaryMatch[1];
-            return await parseMultipartBody(this.rawRequest, boundary, options);
+            const formData = await this.rawRequest.formData();
+            const result = {};
+            for (const [key, value] of formData.entries()) {
+                let val = value;
+                if (val instanceof File && typeof options == "object") {
+                    let filename = val.name;
+                    if (options?.sanitized) {
+                        filename = `${Date.now()}-${sanitized(filename)}`;
+                    }
+                    if (Array.isArray(options?.allowedTypes) &&
+                        !options.allowedTypes?.includes(val.type)) {
+                        throw new Error(`Invalid file type: "${val.type}". Allowed types: ${options.allowedTypes.join(", ")}`);
+                    }
+                    if (typeof options?.maxSize !== "undefined" &&
+                        val.size > options.maxSize) {
+                        throw new Error(`File size exceeds the limit: ${val.size} bytes (Max: ${options.maxSize} bytes)`);
+                    }
+                    if (typeof options?.maxFiles != "undefined" && options.maxFiles == 0) {
+                        throw new Error(`Field "${key}" exceeds the maximum allowed file count of ${options.maxFiles}.`);
+                    }
+                    val = new File([await val.arrayBuffer()], filename, {
+                        type: val.type,
+                    });
+                }
+                if (result[key]) {
+                    if (Array.isArray(result[key])) {
+                        if (val instanceof File &&
+                            typeof options?.maxFiles != "undefined" &&
+                            result[key]?.length >= options.maxFiles) {
+                            throw new Error(`Field "${key}" exceeds the maximum allowed file count of ${options.maxFiles}.`);
+                        }
+                        result[key].push(val);
+                    }
+                    else {
+                        if (val instanceof File &&
+                            typeof options?.maxFiles != "undefined" &&
+                            options.maxFiles == 1) {
+                            throw new Error(`Field "${key}" exceeds the maximum allowed file count of ${options.maxFiles}.`);
+                        }
+                        result[key] = [result[key], val];
+                    }
+                }
+                else {
+                    result[key] = val;
+                }
+            }
+            return result;
         }
         else {
             return {};

package/core/router.d.ts

@@ -79,6 +79,35 @@ export declare class Router<T extends Record<string, any> = {}> extends Middlewa
     get(path: string, callback: Callback<T>): this;
     get(path: string, middleware: Middleware<T>, callback: Callback<T>): this;
     get(path: string, middlewares: Middleware<T>[], callback: Callback<T>): this;
+    /**
+     * Registers a Server-Sent Events (SSE) route handler for the given path.
+     *
+     * This method sets up an HTTP GET route that sends real-time updates to the client
+     * over a persistent HTTP connection using the SSE protocol.
+     *
+     * ### Example:
+     * ```ts
+     * app.sse("/events", async (ctx) => {
+     *   const stream = new ReadableStream({
+     *     start(controller) {
+     *       controller.enqueue(new TextEncoder().encode("data: Hello\n\n"));
+     *     },
+     *   });
+     *
+     *   return ctx.send(stream, {
+     *     headers: {
+     *       "Content-Type": "text/event-stream",
+     *       "Cache-Control": "no-cache",
+     *       "Connection": "keep-alive",
+     *     },
+     *   });
+     * });
+     * ```
+     *
+     * @param {string} path - The route path for SSE (e.g. `/events`).
+     * @param {(ctx: Context) => any} handler - A handler function that returns a streamed response.
+     */
+    sse(path: string, handler: (ctx: Context) => any): void;
     /**
      * Registers a POST route with optional middleware(s)
      * @param path - URL path pattern
@@ -183,6 +212,7 @@ export declare class Router<T extends Record<string, any> = {}> extends Middlewa
     use(path: string, middlewares: Middleware<T>[], callback: Callback<T> | Router<T | any>): this;
     use(path: string, middleware: Middleware<T>, callback: Callback<T> | Router<T | any>): this;
     use(path: string, middlewares: Middleware<T>[]): this;
+    use(path: string, middlewares: Middleware<T>): this;
     use(path: string, callback: Callback<T> | Router<T | any>): this;
     use(middlewares: Middleware<T>[], callback: Callback<T> | Router<T | any>): this;
     use(middleware: Middleware<T>, callback: Callback<T> | Router<T | any>): this;

package/core/router.js

@@ -59,6 +59,11 @@ export class Router extends MiddlewareConfigure {
         this.#registerRoute("GET", path, ...args);
         return this;
     }
+    sse(path, handler) {
+        this.get(path, async (ctx) => {
+            return handler(ctx);
+        });
+    }
     post(path, ...args) {
         this.#registerRoute("POST", path, ...args);
         return this;

package/core/server.js

@@ -1,7 +1,8 @@
 import { COLORS } from "../utils/colors.js";
+import { httpStatusMap } from "../utils/httpStatusMap.js";
 import { useParams } from "../utils/params.js";
 import { GlobalConfig } from "./config.js";
-import { Context, httpStatusMap } from "./context.js";
+import { Context } from "./context.js";
 import { Router } from "./router.js";
 export class TezX extends Router {
     #onPathResolve;
@@ -194,12 +195,12 @@ export class TezX extends Router {
             }
             let finalResponse = () => {
                 return (ctx) => {
-                    if (response?.headers) {
-                        ctx.headers.add(response.headers);
+                    for (const [key, value] of response?.headers.entries()) {
+                        ctx.headers.set(key, value);
                     }
                     const statusText = response?.statusText || httpStatusMap[response?.status] || "";
                     const status = response.status || ctx.getStatus;
-                    let headers = ctx.headers.toObject();
+                    let headers = ctx.headers.toJSON();
                     return new Response(response.body, {
                         status,
                         statusText,

package/index.js

@@ -1,4 +1,4 @@
 export { Router } from "./core/router.js";
 export { TezX } from "./core/server.js";
 export { useParams } from "./utils/params.js";
-export let version = "1.0.73";
+export let version = "1.0.75-beta";

package/middleware/basicAuth.js

@@ -12,7 +12,7 @@ export const basicAuth = (options) => {
     if (rateLimit && !rateLimit.storage) {
         storage = createRateLimitDefaultStorage();
     }
-    return async (ctx, next) => {
+    return async function basicAuth(ctx, next) {
         let authMethod;
         let credentials = {};
         const authHeader = ctx.req.headers.get("authorization");

package/middleware/cacheControl.js

@@ -8,7 +8,7 @@ export const cacheControl = (options) => {
             GlobalConfig.debugging.success(`[CACHE] ${event.toUpperCase()} for ${ctx.method} ${ctx.pathname}`);
         }
     }, } = options;
-    return async (ctx, next) => {
+    return async function cacheControl(ctx, next) {
         if (!["GET", "HEAD"].includes(ctx.method)) {
             return await next();
         }

package/middleware/cors.js

@@ -1,6 +1,6 @@
 export function cors(option = {}) {
     const { methods, allowedHeaders, credentials, exposedHeaders, maxAge, origin, } = option;
-    return async (ctx, next) => {
+    return async function cors(ctx, next) {
         const reqOrigin = ctx.req.headers.get("origin") || "";
         let allowOrigin = "*";
         if (typeof origin === "string") {
@@ -38,7 +38,7 @@ export function cors(option = {}) {
         if (ctx.req.method === "OPTIONS") {
             return new Response(null, {
                 status: 204,
-                headers: ctx.headers.toObject(),
+                headers: ctx.headers.toJSON(),
             });
         }
         return await next();

package/middleware/detectBot.js

@@ -8,7 +8,7 @@ export const detectBot = (options = {}) => {
     if (enableRateLimiting) {
         store = createRateLimitDefaultStorage();
     }
-    return async (ctx, next) => {
+    return async function detectBot(ctx, next) {
         const detectionResult = {
             isBot: false,
             indicators: [],

package/middleware/detectLocale.js

@@ -1,7 +1,7 @@
 import { GlobalConfig } from "../core/config.js";
 export const detectLocale = (options) => {
     const { supportedLocales, defaultLocale = "en", queryKeyLocale = "lang", cookieKeyLocale = "locale", localeContextKey = "locale", customLocaleDetector, } = options;
-    return async (ctx, next) => {
+    return async function detectLocale(ctx, next) {
         let detectedLocale;
         const queryLocale = ctx.req.query[queryKeyLocale];
         if (queryLocale && supportedLocales.includes(queryLocale)) {

package/middleware/{i18nMiddleware.d.ts → i18n.d.ts}

@@ -86,16 +86,16 @@ export type I18nOptions = {
  *
  * @example
  * // Basic usage
- * app.use(i18nMiddleware({
+ * app.use(i18n({
  *   loadTranslations: lang => import(`./locales/${lang}.json`),
  *   defaultLanguage: 'en'
  * }));
  *
  * // With caching and custom detection
- * app.use(i18nMiddleware({
+ * app.use(i18n({
  *   loadTranslations: fetchTranslations,
  *   detectLanguage: ctx => ctx.get('X-Language'),
  *   cacheTranslations: true
  * }));
  */
-export declare const i18nMiddleware: (options: I18nOptions) => Middleware;
+export declare const i18n: (options: I18nOptions) => Middleware;

package/middleware/{i18nMiddleware.js → i18n.js}

@@ -1,5 +1,5 @@
 import { GlobalConfig } from "../core/config.js";
-export const i18nMiddleware = (options) => {
+export const i18n = (options) => {
     const { loadTranslations, defaultCacheDuration = 3600000, isCacheValid = (cached) => cached.expiresAt > Date.now(), detectLanguage = (ctx) => ctx.req.query.lang ||
         ctx.cookies?.get("lang") ||
         ctx.req.headers.get("accept-language")?.split(",")[0] ||
@@ -8,7 +8,7 @@ export const i18nMiddleware = (options) => {
         return Object.entries(options).reduce((msg, [key, value]) => msg.replace(new RegExp(`{{${key}}}`, "g"), String(value)), message);
     }, cacheTranslations = true, } = options;
     const translationCache = {};
-    return async (ctx, next) => {
+    return async function i18n(ctx, next) {
         try {
             const detectedLanguage = detectLanguage(ctx);
             const languageChain = [

package/middleware/index.d.ts

@@ -4,7 +4,7 @@ export type { CorsOptions } from "./cors.js";
 export { detectBot } from "./detectBot.js";
 export type { DetectBotReason } from "./detectBot.js";
 export * from "./detectLocale.js";
-export * from "./i18nMiddleware.js";
+export * from "./i18n.js";
 export * from "./lazyLoadModules.js";
 export * from "./logger.js";
 export * from "./pagination.js";

package/middleware/index.js

@@ -2,7 +2,7 @@ export * from "./basicAuth.js";
 export { cors } from "./cors.js";
 export { detectBot } from "./detectBot.js";
 export * from "./detectLocale.js";
-export * from "./i18nMiddleware.js";
+export * from "./i18n.js";
 export * from "./lazyLoadModules.js";
 export * from "./logger.js";
 export * from "./pagination.js";

package/middleware/lazyLoadModules.js

@@ -5,7 +5,7 @@ export const lazyLoadModules = (options) => {
     if (enableCache && !cacheStorage) {
         storage = new Map();
     }
-    return async (ctx, next) => {
+    return async function lazyLoadModules(ctx, next) {
         let moduleName = moduleKey(ctx) ||
             ctx.req.params[queryKeyModule] ||
             ctx.req.query[queryKeyModule];

package/middleware/logger.js

@@ -1,6 +1,6 @@
 import { COLORS } from "../utils/colors.js";
 export function logger() {
-    return async (ctx, next) => {
+    return async function logger(ctx, next) {
         try {
             console.log(`${COLORS.bold}<-- ${COLORS.reset}${COLORS.bgMagenta} ${ctx.method} ${COLORS.reset} ${ctx.pathname}`);
             const startTime = performance.now();

package/middleware/pagination.js

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

package/middleware/powered-by.js

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

package/middleware/rateLimiter.js

@@ -4,7 +4,7 @@ export const rateLimiter = (options) => {
         ctx.setStatus = 429;
         throw new Error(`Rate limit exceeded. Try again in ${retryAfter} seconds.`);
     }, } = options;
-    return async (ctx, next) => {
+    return async function rateLimiter(ctx, next) {
         const key = keyGenerator(ctx);
         const { check, entry } = isRateLimit(ctx, key, storage, maxRequests, windowMs);
         if (check) {

package/middleware/request-id.js

@@ -1,6 +1,6 @@
 import { generateID } from "../helper/index.js";
 export const requestID = (headerName = "X-Request-ID", contextKey = "requestID") => {
-    return (ctx, next) => {
+    return function requestID(ctx, next) {
         const existingID = ctx.headers?.get(headerName.toLowerCase()) ||
             ctx.headers?.get(headerName);
         const requestId = existingID || `req-${generateID()}`;

package/middleware/requestTimeout.js

@@ -7,7 +7,7 @@ export const requestTimeout = (options) => {
         GlobalConfig.debugging.warn(`[TIMEOUT] ${error.message}: ${ctx.method} ${ctx.path}`);
     }, cleanup = () => {
     }, } = options;
-    return async (ctx, next) => {
+    return async function requestTimeout(ctx, next) {
         let timeoutId = null;
         try {
             const timeout = getTimeout(ctx);

package/middleware/sanitizeHeader.js

@@ -1,7 +1,7 @@
 import { GlobalConfig } from "../core/config.js";
 export const sanitizeHeaders = (options = {}) => {
     const { whitelist = [], blacklist = [], normalizeKeys = true, allowUnsafeCharacters = false, } = options;
-    return async (ctx, next) => {
+    return async function sanitizeHeaders(ctx, next) {
         const sanitizedHeaders = new Map();
         for (const [key, values] of ctx.headers.entries()) {
             if (!Array.isArray(values) || values.length === 0) {
@@ -28,9 +28,9 @@ export const sanitizeHeaders = (options = {}) => {
                 GlobalConfig.debugging.warn(`⚠️ All values for "${normalizedKey}" invalid - removed`);
                 continue;
             }
-            sanitizedHeaders.set(normalizedKey, sanitizedValues);
+            sanitizedHeaders.set(normalizedKey, sanitizedValues?.join(", "));
         }
-        ctx.headers.clear().add([...sanitizedHeaders.entries()]);
+        ctx.headers = new Headers(sanitizedHeaders);
         return await next();
     };
 };

package/middleware/secureHeaders.js

@@ -1,5 +1,5 @@
 export const secureHeaders = (options = {}) => {
-    return async (ctx, next) => {
+    return async function secureHeaders(ctx, next) {
         const resolveValue = (value) => {
             return typeof value === "function" ? value(ctx) : value;
         };

package/middleware/xssProtection.js

@@ -1,7 +1,7 @@
 import { GlobalConfig } from "../core/config.js";
 export const xssProtection = (options = {}) => {
     const { enabled = true, mode = "block", fallbackCSP = "default-src 'self'; script-src 'self';", } = options;
-    return async (ctx, next) => {
+    return async function xssProtection(ctx, next) {
         const isEnabled = typeof enabled === "function" ? enabled(ctx) : enabled;
         if (!isEnabled) {
             GlobalConfig.debugging.warn("🟠 XSS protection is disabled.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tezx",
-  "version": "1.0.73",
+  "version": "1.0.75-beta",
   "description": "TezX is a high-performance, lightweight JavaScript framework designed for speed, scalability, and flexibility. It enables efficient routing, middleware management, and static file serving with minimal configuration. Fully compatible with Node.js, Deno, and Bun.",
   "main": "cjs/index.js",
   "module": "index.js",

package/utils/formData.d.ts

@@ -1,6 +1 @@
-import { FormDataOptions } from "../core/request.js";
-export declare function parseJsonBody(req: any): Promise<Record<string, any>>;
-export declare function parseTextBody(req: any): Promise<string>;
-export declare function parseUrlEncodedBody(req: any): Promise<Record<string, any>>;
 export declare function sanitized(title: string): string;
-export declare function parseMultipartBody(req: any, boundary: string, options?: FormDataOptions): Promise<Record<string, any>>;