tezx 1.0.74 → 1.0.76-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

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.74";
+export let version = "1.0.76-beta";

package/middleware/cors.js

@@ -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/sanitizeHeader.js

@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tezx",
-  "version": "1.0.74",
+  "version": "1.0.76-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>>;

package/utils/formData.js

@@ -1,90 +1,3 @@
-import { GlobalConfig } from "../core/config.js";
-export async function parseJsonBody(req) {
-    const runtime = GlobalConfig.adapter;
-    if (runtime === "node") {
-        return new Promise((resolve, reject) => {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString();
-            });
-            req.on("end", () => {
-                try {
-                    resolve(JSON.parse(body));
-                }
-                catch (error) {
-                    reject(new Error("Invalid JSON format"));
-                }
-            });
-        });
-    }
-    else if (runtime === "deno" || runtime === "bun") {
-        return await req.json();
-    }
-    else {
-        throw new Error("Unsupported environment for multipart parsing");
-    }
-}
-export async function parseTextBody(req) {
-    const runtime = GlobalConfig.adapter;
-    if (runtime === "node") {
-        return new Promise((resolve, reject) => {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString();
-            });
-            req.on("end", () => {
-                try {
-                    resolve(body);
-                }
-                catch (error) {
-                    reject(new Error("Invalid JSON format"));
-                }
-            });
-        });
-    }
-    else if (runtime === "deno" || runtime === "bun") {
-        return await req.text();
-    }
-    else {
-        throw new Error("Unsupported environment for multipart parsing");
-    }
-}
-export async function parseUrlEncodedBody(req) {
-    const runtime = GlobalConfig.adapter;
-    if (runtime === "node") {
-        return new Promise((resolve, reject) => {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString("binary");
-            });
-            req.on("end", () => {
-                try {
-                    const pairs = body.split("&");
-                    const formData = {};
-                    pairs.forEach((pair) => {
-                        const [key, value] = pair.split("=");
-                        formData[decodeURIComponent(key)] = decodeURIComponent(value || "");
-                    });
-                    resolve(formData);
-                }
-                catch {
-                    reject(new Error("Invalid x-www-form-urlencoded format"));
-                }
-            });
-        });
-    }
-    else if (runtime === "deno" || runtime === "bun") {
-        const formData = await req.formData();
-        const result = {};
-        for (const [key, value] of formData.entries()) {
-            result[key] = value;
-        }
-        return result;
-    }
-    else {
-        throw new Error("Unsupported environment for multipart parsing");
-    }
-}
 export function sanitized(title) {
     const base = title
         .toLowerCase()
@@ -95,147 +8,3 @@ export function sanitized(title) {
         .replace(/^-+|-+$/g, "");
     return base;
 }
-export async function parseMultipartBody(req, boundary, options) {
-    const runtime = GlobalConfig.adapter;
-    if (runtime === "node") {
-        return new Promise((resolve, reject) => {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString("binary");
-            });
-            req.on("end", () => {
-                try {
-                    const formDataField = {};
-                    const formDataFieldParts = body.split("----------------------------");
-                    formDataFieldParts.forEach((part) => {
-                        const match = part.match(/name="(.*)"\r\n\r\n(.*)\r\n/);
-                        if (match && match.length === 3) {
-                            const name = match[1];
-                            const value = match[2];
-                            if (formDataField[name]) {
-                                if (Array.isArray(formDataField[name])) {
-                                    formDataField[name].push(value);
-                                }
-                                else {
-                                    formDataField[name] = [formDataField[name], value];
-                                }
-                            }
-                            else {
-                                formDataField[name] = value;
-                            }
-                        }
-                    });
-                    const parts = body.split(`--${boundary}`);
-                    for (const part of parts) {
-                        if (part.includes("filename")) {
-                            const filenameMatch = part.match(/filename="([^"]+)"/);
-                            const fieldNameMatch = part.match(/name="([^"]+)"/);
-                            const contentTypeMatch = part.match(/Content-Type: ([^\r\n]+)/);
-                            if (filenameMatch && fieldNameMatch && contentTypeMatch) {
-                                let filename = filenameMatch[1];
-                                const fieldName = fieldNameMatch[1];
-                                const contentType = contentTypeMatch[1];
-                                if (options?.sanitized) {
-                                    filename = `${Date.now()}-${sanitized(filename)}`;
-                                }
-                                if (Array.isArray(options?.allowedTypes) &&
-                                    !options.allowedTypes?.includes(contentType)) {
-                                    reject(new Error(`Invalid file type: "${contentType}". Allowed types: ${options.allowedTypes.join(", ")}`));
-                                }
-                                const fileContentStartIndex = part.indexOf("\r\n\r\n") + 4;
-                                const fileContent = Buffer.from(part.substring(fileContentStartIndex), "binary");
-                                const arrayBuffer = fileContent.buffer.slice(fileContent.byteOffset, fileContent.byteOffset + fileContent.byteLength);
-                                if (typeof options?.maxSize !== "undefined" &&
-                                    fileContent.byteLength > options.maxSize) {
-                                    reject(new Error(`File size exceeds the limit: ${fileContent.byteLength} bytes (Max: ${options.maxSize} bytes)`));
-                                }
-                                const file = new File([arrayBuffer], filename, {
-                                    type: contentType,
-                                });
-                                if (typeof options?.maxFiles != "undefined" &&
-                                    options.maxFiles == 0) {
-                                    reject(new Error(`Field "${fieldName}" exceeds the maximum allowed file count of ${options.maxFiles}.`));
-                                }
-                                if (formDataField[fieldName]) {
-                                    if (Array.isArray(formDataField[fieldName])) {
-                                        const existingFiles = formDataField[fieldName].filter((f) => f instanceof File);
-                                        if (typeof options?.maxFiles != "undefined" &&
-                                            existingFiles.length >= options.maxFiles) {
-                                            reject(new Error(`Field "${fieldName}" exceeds the maximum allowed file count of ${options.maxFiles}.`));
-                                        }
-                                        formDataField[fieldName].push(file);
-                                    }
-                                    else {
-                                        if (formDataField[fieldName] instanceof File &&
-                                            typeof options?.maxFiles != "undefined" &&
-                                            options.maxFiles == 1) {
-                                            reject(new Error(`Field "${fieldName}" exceeds the maximum allowed file count of ${options.maxFiles}.`));
-                                        }
-                                        formDataField[fieldName] = [formDataField[fieldName], file];
-                                    }
-                                }
-                                else {
-                                    formDataField[fieldName] = file;
-                                }
-                            }
-                        }
-                    }
-                    resolve(formDataField);
-                }
-                catch { }
-            });
-        });
-    }
-    else if (runtime === "deno" || runtime === "bun") {
-        const formData = await req.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 {
-        throw new Error("Unsupported environment for multipart parsing");
-    }
-}

package/utils/httpStatusMap.d.ts

@@ -0,0 +1 @@
+export declare const httpStatusMap: Record<number, string>;