tezx 4.0.1 → 4.0.2

package/cjs/core/context.js

@@ -12,7 +12,6 @@ class Context {
     params = {};
     rawRequest;
     #server;
-    #body;
     url;
     res;
     pathname;
@@ -44,12 +43,6 @@ class Context {
     get req() {
         return (this.#req ??= new request_js_1.TezXRequest(this.rawRequest, this.method, this.pathname, this.params));
     }
-    get body() {
-        return this.#body;
-    }
-    set body(value) {
-        this.#body = value;
-    }
     status(status) {
         this.#status = status;
         return this;

package/cjs/core/server.js

@@ -4,23 +4,18 @@ exports.TezX = void 0;
 const RadixRouter_js_1 = require("../registry/RadixRouter.js");
 const response_js_1 = require("../utils/response.js");
 const url_js_1 = require("../utils/url.js");
-const index_js_1 = require("../config/index.js");
 const context_js_1 = require("./context.js");
 const router_js_1 = require("./router.js");
 class TezX extends router_js_1.Router {
     #pathResolver;
     #notFound = response_js_1.notFoundResponse;
     #errorHandler = response_js_1.handleErrorResponse;
-    constructor({ basePath = "/", debugMode = false, onPathResolve, routeRegistry = new RadixRouter_js_1.RadixRouter(), } = {}) {
-        if (debugMode) {
-            index_js_1.Config.debugMode = debugMode;
-        }
+    constructor({ basePath = "/", routeRegistry = new RadixRouter_js_1.RadixRouter(), } = {}) {
         super({ basePath });
         if (!routeRegistry) {
             throw new Error("routeRegistry is required for TezX initialization");
         }
         this.router = routeRegistry;
-        this.#pathResolver = onPathResolve;
         this.serve = this.serve.bind(this);
     }
     notFound(callback) {
@@ -31,64 +26,49 @@ class TezX extends router_js_1.Router {
         this.#errorHandler = callback;
         return this;
     }
-    async #chain(ctx, mLen, middlewares, hLen, handlers) {
+    #composeChain(ctx, stack) {
         let index = -1;
-        let res;
-        async function dispatch(i) {
+        const dispatch = (i) => {
             if (i <= index)
                 throw new Error("next() called multiple times");
             index = i;
-            if (i < mLen) {
-                const fn = middlewares[i];
-                if (typeof fn !== "function")
-                    throw new TypeError(`Middleware[${i}] must be a function`);
-                res = (await fn(ctx, () => dispatch(i + 1)));
-                if (res !== undefined) {
-                    ctx.res = res;
-                }
+            const fn = stack[i];
+            if (!fn)
+                return ctx.res;
+            const result = fn(ctx, () => dispatch(i + 1));
+            if (!(result instanceof Promise)) {
+                if (result instanceof Response)
+                    ctx.res = result;
                 return ctx.res;
             }
-            const hi = i - mLen;
-            if (hi < hLen) {
-                const fn = handlers[hi];
-                if (typeof fn !== "function")
-                    throw new TypeError(`Handler[${hi}] must be a function`);
-                res = (await fn(ctx, () => dispatch(i + 1)));
-                if (res !== undefined) {
+            return result.then((res) => {
+                if (res instanceof Response)
                     ctx.res = res;
-                }
                 return ctx.res;
-            }
-        }
-        await dispatch(0);
-        return (ctx.res ??
-            (ctx.body !== undefined ? ctx.send(ctx.body) : this.#notFound(ctx)));
+            }, (err) => {
+                throw err;
+            });
+        };
+        return dispatch(0);
     }
     async #handleRequest(req, method, server) {
-        if (!(req instanceof Request))
-            throw new Error("Invalid request object provided to tezX server.");
-        const rawPath = (0, url_js_1.getPathname)(req.url);
-        const pathname = this.#pathResolver
-            ? await this.#pathResolver(rawPath)
-            : rawPath;
+        const pathname = (0, url_js_1.getPathname)(req.url);
         const ctx = new context_js_1.Context(req, pathname, method, server);
         try {
             const staticHandler = this.staticFile?.[`${method} ${pathname}`];
-            if (staticHandler) {
+            if (staticHandler)
                 return staticHandler(ctx);
-            }
-            const route = this.router?.search(method, pathname);
-            const mLen = route?.middlewares?.length;
-            const hLen = route?.handlers?.length;
-            if (!route || (hLen === 0 && mLen === 0)) {
+            const result = this.router?.search(method, pathname);
+            if (!result)
                 return this.#notFound(ctx);
-            }
-            ctx.params = route.params;
-            if (hLen === 1 && mLen === 0) {
-                return ((await route.handlers[0](ctx)) ??
-                    (ctx.body !== undefined ? ctx.send(ctx.body) : this.#notFound(ctx)));
-            }
-            return await this.#chain(ctx, mLen, route.middlewares, hLen, route.handlers);
+            const { match: middlewares, params } = result;
+            const mLen = middlewares.length;
+            if (mLen === 0)
+                return this.#notFound(ctx);
+            ctx.params = params;
+            if (mLen === 1)
+                return await middlewares[0](ctx) ?? this.#notFound(ctx);
+            return await this.#composeChain(ctx, middlewares) ?? this.#notFound(ctx);
         }
         catch (err) {
             let error = err instanceof Error ? err : new Error(String(err));
@@ -96,20 +76,17 @@ class TezX extends router_js_1.Router {
         }
     }
     async serve(req, server) {
-        const method = (req.method ?? "GET").toUpperCase();
+        const method = req.method || "GET";
         if (method === "HEAD") {
-            const getRequest = new Request(req.url, { ...req, method: "GET" });
-            const headResponse = await this.#handleRequest(getRequest, method, server);
+            const headReq = new Request(req, { method: "GET" });
+            const res = await this.#handleRequest(headReq, "GET", server);
             return new Response(null, {
-                status: headResponse.status,
-                statusText: headResponse.statusText,
-                headers: headResponse.headers,
+                status: res.status,
+                statusText: res.statusText,
+                headers: res.headers,
             });
         }
         return this.#handleRequest(req, method, server);
     }
 }
 exports.TezX = TezX;
-if (!globalThis.TezX) {
-    globalThis.TezX = TezX;
-}

package/cjs/index.js

@@ -5,7 +5,7 @@ const router_js_1 = require("./core/router.js");
 Object.defineProperty(exports, "Router", { enumerable: true, get: function () { return router_js_1.Router; } });
 const server_js_1 = require("./core/server.js");
 Object.defineProperty(exports, "TezX", { enumerable: true, get: function () { return server_js_1.TezX; } });
-exports.version = "4.0.1";
+exports.version = "4.0.2";
 exports.default = {
     Router: router_js_1.Router,
     TezX: server_js_1.TezX,

package/cjs/registry/RadixRouter.js

@@ -39,12 +39,18 @@ class RadixRouter {
     search(method, path) {
         let params = {};
         let middlewares = [];
-        const { success, node } = this._match(method, this.root, path?.split("/")?.filter(Boolean), 0, params, middlewares);
-        if (success && node) {
-            const handlers = node.handlers?.[method] ?? [];
-            return { method, params, handlers, middlewares };
+        const segments = path?.split("/")?.filter(Boolean);
+        const { success, node } = this._match(method, this.root, segments, 0, params, middlewares);
+        if (!success || !node) {
+            return { method, params: {}, match: [] };
         }
-        return { method, params: {}, handlers: [], middlewares };
+        const list = node.handlers?.[method];
+        if (list) {
+            for (let i = 0; i < list.length; i++) {
+                middlewares.push(list[i]);
+            }
+        }
+        return { method, params, match: middlewares };
     }
     _match(method, node, segments, index, params, middlewares) {
         if (node?.handlers?.ALL) {

package/cjs/utils/response.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.notFoundResponse = void 0;
 exports.mergeHeaders = mergeHeaders;
 exports.handleErrorResponse = handleErrorResponse;
-const index_js_1 = require("../config/index.js");
 let notFoundResponse = (ctx) => {
     const { method, pathname } = ctx;
     return ctx.text(`${method}: '${pathname}' could not find\n`, {
@@ -11,24 +10,25 @@ let notFoundResponse = (ctx) => {
     });
 };
 exports.notFoundResponse = notFoundResponse;
-function mergeHeaders(existing, initHeaders) {
+function mergeHeaders(existing, init) {
     if (!existing)
-        return new Headers(initHeaders);
-    if (!initHeaders)
+        return new Headers(init);
+    if (!init)
         return existing;
     const out = new Headers(existing);
-    const tmp = new Headers(initHeaders);
-    for (const [k, v] of tmp) {
-        if (k.toLowerCase() === "set-cookie")
-            out.append(k, v);
-        else
-            out.set(k, v);
+    for (const key in init) {
+        const val = init[key];
+        if (val && key.toLowerCase() === "set-cookie") {
+            out.append(key, val);
+        }
+        else if (val) {
+            out.set(key, val);
+        }
     }
     return out;
 }
 async function handleErrorResponse(err = new Error("Internal Server Error"), ctx) {
     if (err instanceof Error) {
-        index_js_1.Config.debugging.error(err?.message);
         return ctx.status(500).send(err.message ?? "Internal Server Error");
     }
     return await handleErrorResponse(new Error(err), ctx);

package/core/context.d.ts

@@ -102,16 +102,6 @@ export declare class Context<TPath extends string = any> {
      * @returns {TezXRequest<TPath>} The wrapped request.
      */
     get req(): TezXRequest<TPath>;
-    /**
-     * Gets the response body.
-     * @returns {*} The response body.
-     */
-    get body(): any;
-    /**
-     * Sets the response body.
-     * @param {*} value - The response body.
-     */
-    set body(value: any);
     /**
      * Sets the HTTP response status code.
      *

package/core/context.js

@@ -9,7 +9,6 @@ export class Context {
     params = {};
     rawRequest;
     #server;
-    #body;
     url;
     res;
     pathname;
@@ -41,12 +40,6 @@ export class Context {
     get req() {
         return (this.#req ??= new TezXRequest(this.rawRequest, this.method, this.pathname, this.params));
     }
-    get body() {
-        return this.#body;
-    }
-    set body(value) {
-        this.#body = value;
-    }
     status(status) {
         this.#status = status;
         return this;

package/core/server.d.ts

@@ -1,38 +1,11 @@
 import { Callback, ErrorHandler, RouteRegistry } from "../types/index.js";
 import { Router, RouterConfig } from "./router.js";
 export type TezXConfig = {
-    /**
-     * 🔄 Hook to transform or normalize the incoming request pathname before routing.
-     *
-     * This function allows you to customize how incoming paths are handled.
-     * You can use it to:
-     * - Remove trailing slashes
-     * - Normalize casing
-     * - Rewrite certain paths dynamically
-     * - Add localization or versioning prefixes
-     *
-     * @example
-     * ```ts
-     * onPathResolve: (pathname) => pathname.replace(/\/+$/, "").toLowerCase()
-     * ```
-     *
-     * @param pathname - The raw incoming request path (e.g., `/Api/Users/`)
-     * @returns The transformed or resolved path used for routing (e.g., `/api/users`)
-     */
-    onPathResolve?: (pathname: string) => string;
     /**
      * Custom route registry instance used internally to store routes.
      * If not provided, the router will use the default CombineRouteRegistry.
      */
     routeRegistry?: RouteRegistry;
-    /**
-     * Enables or disables debugging for the middleware.
-     * When set to `true`, detailed debug logs will be output,
-     * useful for tracking the flow of requests and identifying issues.
-     *
-     * @default false
-     */
-    debugMode?: boolean;
 } & RouterConfig;
 /**
  * TezX is an ultra-fast, flexible request router and server handler.
@@ -52,7 +25,7 @@ export declare class TezX<T extends Record<string, any> = {}> extends Router<T>
     #private;
     /** Internal route registry to hold all routes */
     protected router?: RouteRegistry;
-    constructor({ basePath, debugMode, onPathResolve, routeRegistry, }?: TezXConfig);
+    constructor({ basePath, routeRegistry, }?: TezXConfig);
     /**
      * Register a custom 404 (not found) handler.
      *

package/core/server.js

@@ -1,23 +1,18 @@
 import { RadixRouter } from "../registry/RadixRouter.js";
 import { handleErrorResponse, notFoundResponse } from "../utils/response.js";
 import { getPathname } from "../utils/url.js";
-import { Config } from "../config/index.js";
 import { Context } from "./context.js";
 import { Router } from "./router.js";
 export class TezX extends Router {
     #pathResolver;
     #notFound = notFoundResponse;
     #errorHandler = handleErrorResponse;
-    constructor({ basePath = "/", debugMode = false, onPathResolve, routeRegistry = new RadixRouter(), } = {}) {
-        if (debugMode) {
-            Config.debugMode = debugMode;
-        }
+    constructor({ basePath = "/", routeRegistry = new RadixRouter(), } = {}) {
         super({ basePath });
         if (!routeRegistry) {
             throw new Error("routeRegistry is required for TezX initialization");
         }
         this.router = routeRegistry;
-        this.#pathResolver = onPathResolve;
         this.serve = this.serve.bind(this);
     }
     notFound(callback) {
@@ -28,64 +23,49 @@ export class TezX extends Router {
         this.#errorHandler = callback;
         return this;
     }
-    async #chain(ctx, mLen, middlewares, hLen, handlers) {
+    #composeChain(ctx, stack) {
         let index = -1;
-        let res;
-        async function dispatch(i) {
+        const dispatch = (i) => {
             if (i <= index)
                 throw new Error("next() called multiple times");
             index = i;
-            if (i < mLen) {
-                const fn = middlewares[i];
-                if (typeof fn !== "function")
-                    throw new TypeError(`Middleware[${i}] must be a function`);
-                res = (await fn(ctx, () => dispatch(i + 1)));
-                if (res !== undefined) {
-                    ctx.res = res;
-                }
+            const fn = stack[i];
+            if (!fn)
+                return ctx.res;
+            const result = fn(ctx, () => dispatch(i + 1));
+            if (!(result instanceof Promise)) {
+                if (result instanceof Response)
+                    ctx.res = result;
                 return ctx.res;
             }
-            const hi = i - mLen;
-            if (hi < hLen) {
-                const fn = handlers[hi];
-                if (typeof fn !== "function")
-                    throw new TypeError(`Handler[${hi}] must be a function`);
-                res = (await fn(ctx, () => dispatch(i + 1)));
-                if (res !== undefined) {
+            return result.then((res) => {
+                if (res instanceof Response)
                     ctx.res = res;
-                }
                 return ctx.res;
-            }
-        }
-        await dispatch(0);
-        return (ctx.res ??
-            (ctx.body !== undefined ? ctx.send(ctx.body) : this.#notFound(ctx)));
+            }, (err) => {
+                throw err;
+            });
+        };
+        return dispatch(0);
     }
     async #handleRequest(req, method, server) {
-        if (!(req instanceof Request))
-            throw new Error("Invalid request object provided to tezX server.");
-        const rawPath = getPathname(req.url);
-        const pathname = this.#pathResolver
-            ? await this.#pathResolver(rawPath)
-            : rawPath;
+        const pathname = getPathname(req.url);
         const ctx = new Context(req, pathname, method, server);
         try {
             const staticHandler = this.staticFile?.[`${method} ${pathname}`];
-            if (staticHandler) {
+            if (staticHandler)
                 return staticHandler(ctx);
-            }
-            const route = this.router?.search(method, pathname);
-            const mLen = route?.middlewares?.length;
-            const hLen = route?.handlers?.length;
-            if (!route || (hLen === 0 && mLen === 0)) {
+            const result = this.router?.search(method, pathname);
+            if (!result)
                 return this.#notFound(ctx);
-            }
-            ctx.params = route.params;
-            if (hLen === 1 && mLen === 0) {
-                return ((await route.handlers[0](ctx)) ??
-                    (ctx.body !== undefined ? ctx.send(ctx.body) : this.#notFound(ctx)));
-            }
-            return await this.#chain(ctx, mLen, route.middlewares, hLen, route.handlers);
+            const { match: middlewares, params } = result;
+            const mLen = middlewares.length;
+            if (mLen === 0)
+                return this.#notFound(ctx);
+            ctx.params = params;
+            if (mLen === 1)
+                return await middlewares[0](ctx) ?? this.#notFound(ctx);
+            return await this.#composeChain(ctx, middlewares) ?? this.#notFound(ctx);
         }
         catch (err) {
             let error = err instanceof Error ? err : new Error(String(err));
@@ -93,19 +73,16 @@ export class TezX extends Router {
         }
     }
     async serve(req, server) {
-        const method = (req.method ?? "GET").toUpperCase();
+        const method = req.method || "GET";
         if (method === "HEAD") {
-            const getRequest = new Request(req.url, { ...req, method: "GET" });
-            const headResponse = await this.#handleRequest(getRequest, method, server);
+            const headReq = new Request(req, { method: "GET" });
+            const res = await this.#handleRequest(headReq, "GET", server);
             return new Response(null, {
-                status: headResponse.status,
-                statusText: headResponse.statusText,
-                headers: headResponse.headers,
+                status: res.status,
+                statusText: res.statusText,
+                headers: res.headers,
             });
         }
         return this.#handleRequest(req, method, server);
     }
 }
-if (!globalThis.TezX) {
-    globalThis.TezX = TezX;
-}

package/index.d.ts

@@ -1,5 +1,5 @@
 import { Router } from "./core/router.js";
-import { TezX, TezX as TezXBase } from "./core/server.js";
+import { TezX } from "./core/server.js";
 export type { Context as BaseContext } from "./core/context.js";
 export type { TezXRequest } from "./core/request.js";
 export type { RouterConfig } from "./core/router.js";
@@ -13,6 +13,3 @@ declare const _default: {
     version: string;
 };
 export default _default;
-declare global {
-    var TezX: typeof TezXBase;
-}

package/index.js

@@ -1,7 +1,7 @@
 import { Router } from "./core/router.js";
 import { TezX } from "./core/server.js";
 export { Router, TezX };
-export let version = "4.0.1";
+export let version = "4.0.2";
 export default {
     Router,
     TezX,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tezx",
-  "version": "4.0.1",
+  "version": "4.0.2",
   "description": "TezX is a modern, ultra-lightweight, and high-performance JavaScript framework built specifically for Bun. It provides a minimal yet powerful API, seamless environment management, and a high-concurrency HTTP engine for building fast, scalable web applications.",
   "type": "module",
   "main": "cjs/index.js",

package/registry/RadixRouter.js

@@ -36,12 +36,18 @@ export class RadixRouter {
     search(method, path) {
         let params = {};
         let middlewares = [];
-        const { success, node } = this._match(method, this.root, path?.split("/")?.filter(Boolean), 0, params, middlewares);
-        if (success && node) {
-            const handlers = node.handlers?.[method] ?? [];
-            return { method, params, handlers, middlewares };
+        const segments = path?.split("/")?.filter(Boolean);
+        const { success, node } = this._match(method, this.root, segments, 0, params, middlewares);
+        if (!success || !node) {
+            return { method, params: {}, match: [] };
         }
-        return { method, params: {}, handlers: [], middlewares };
+        const list = node.handlers?.[method];
+        if (list) {
+            for (let i = 0; i < list.length; i++) {
+                middlewares.push(list[i]);
+            }
+        }
+        return { method, params, match: middlewares };
     }
     _match(method, node, segments, index, params, middlewares) {
         if (node?.handlers?.ALL) {

package/types/index.d.ts

@@ -238,6 +238,12 @@ export type HttpBaseResponse = Response | Promise<Response>;
  */
 export type Ctx<T extends Record<string, any> = {}, Path extends string = any> = Context<Path> & T & {
     [key: string]: any;
+    /**
+     * Response body, can be string, Buffer, stream, etc. like context propagation.
+     * @private
+     * @type {*}
+     */
+    body: any;
 };
 /**
  * A callback (handler) for a route.
@@ -348,11 +354,7 @@ export type RouteMatchResult<T extends Record<string, any> = any> = {
     /**
      * The middleware functions that will be executed for this route.
      */
-    middlewares: Middleware<T>[];
-    /**
-     * The final route handlers (callbacks or middlewares) to be executed.
-     */
-    handlers: HandlerType<T>;
+    match: Middleware<T>[];
     /**
      * An object containing route parameters extracted from the URL.
      * The values can be strings, null (for optional params), or undefined.

package/utils/response.d.ts

@@ -1,5 +1,5 @@
 import { Context } from "../core/context.js";
 import { HttpBaseResponse, ResponseHeaders } from "../types/index.js";
 export declare let notFoundResponse: (ctx: Context) => HttpBaseResponse;
-export declare function mergeHeaders(existing?: Headers, initHeaders?: ResponseHeaders): Headers;
+export declare function mergeHeaders(existing?: Headers, init?: ResponseHeaders): Headers;
 export declare function handleErrorResponse(err: Error | undefined, ctx: Context): Promise<HttpBaseResponse>;

package/utils/response.js

@@ -1,28 +1,28 @@
-import { Config } from "../config/index.js";
 export let notFoundResponse = (ctx) => {
     const { method, pathname } = ctx;
     return ctx.text(`${method}: '${pathname}' could not find\n`, {
         status: 404,
     });
 };
-export function mergeHeaders(existing, initHeaders) {
+export function mergeHeaders(existing, init) {
     if (!existing)
-        return new Headers(initHeaders);
-    if (!initHeaders)
+        return new Headers(init);
+    if (!init)
         return existing;
     const out = new Headers(existing);
-    const tmp = new Headers(initHeaders);
-    for (const [k, v] of tmp) {
-        if (k.toLowerCase() === "set-cookie")
-            out.append(k, v);
-        else
-            out.set(k, v);
+    for (const key in init) {
+        const val = init[key];
+        if (val && key.toLowerCase() === "set-cookie") {
+            out.append(key, val);
+        }
+        else if (val) {
+            out.set(key, val);
+        }
     }
     return out;
 }
 export async function handleErrorResponse(err = new Error("Internal Server Error"), ctx) {
     if (err instanceof Error) {
-        Config.debugging.error(err?.message);
         return ctx.status(500).send(err.message ?? "Internal Server Error");
     }
     return await handleErrorResponse(new Error(err), ctx);

package/cjs/config/index.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Config = void 0;
-const debugging_js_1 = require("../utils/debugging.js");
-let Config = class {
-    static debugMode = false;
-    static get debugging() {
-        return this.debugMode
-            ? {
-                info: (msg, ...args) => (0, debugging_js_1.loggerOutput)("info", msg, ...args),
-                warn: (msg, ...args) => (0, debugging_js_1.loggerOutput)("warn", msg, ...args),
-                error: (msg, ...args) => (0, debugging_js_1.loggerOutput)("error", msg, ...args),
-                debug: (msg, ...args) => (0, debugging_js_1.loggerOutput)("debug", msg, ...args),
-                success: (msg, ...args) => (0, debugging_js_1.loggerOutput)("success", msg, ...args),
-            }
-            : {
-                info: (msg, ...args) => { },
-                warn: (msg, ...args) => { },
-                error: (msg, ...args) => { },
-                debug: (msg, ...args) => { },
-                success: (msg, ...args) => { },
-            };
-    }
-};
-exports.Config = Config;

package/config/index.d.ts

@@ -1,11 +0,0 @@
-export declare let Config: {
-    new (): {};
-    debugMode?: boolean;
-    readonly debugging: {
-        info: (msg: string, ...args: unknown[]) => void;
-        warn: (msg: string, ...args: unknown[]) => void;
-        error: (msg: string, ...args: unknown[]) => void;
-        debug: (msg: string, ...args: unknown[]) => void;
-        success: (msg: string, ...args: unknown[]) => void;
-    };
-};

package/config/index.js

@@ -1,21 +0,0 @@
-import { loggerOutput } from "../utils/debugging.js";
-export let Config = class {
-    static debugMode = false;
-    static get debugging() {
-        return this.debugMode
-            ? {
-                info: (msg, ...args) => loggerOutput("info", msg, ...args),
-                warn: (msg, ...args) => loggerOutput("warn", msg, ...args),
-                error: (msg, ...args) => loggerOutput("error", msg, ...args),
-                debug: (msg, ...args) => loggerOutput("debug", msg, ...args),
-                success: (msg, ...args) => loggerOutput("success", msg, ...args),
-            }
-            : {
-                info: (msg, ...args) => { },
-                warn: (msg, ...args) => { },
-                error: (msg, ...args) => { },
-                debug: (msg, ...args) => { },
-                success: (msg, ...args) => { },
-            };
-    }
-};