tezx 1.0.21 → 1.0.23

package/router.js

@@ -0,0 +1,373 @@
+import { GlobalConfig } from "./config/config";
+import MiddlewareConfigure, { TriMiddleware, } from "./MiddlewareConfigure";
+import { getFiles } from "./utils/staticFile";
+import { sanitizePathSplit } from "./utils/url";
+class TrieRouter {
+    children = new Map();
+    handlers = new Map();
+    pathname;
+    paramName;
+    isParam = false;
+    constructor(pathname = "/") {
+        this.children = new Map();
+        this.pathname = pathname;
+    }
+}
+export class Router extends MiddlewareConfigure {
+    routers = new Map();
+    env = {};
+    triRouter;
+    constructor({ basePath = "/", env = {} } = {}) {
+        super(basePath);
+        this.basePath = basePath;
+        this.env = { ...env };
+        this.triRouter = new TrieRouter(basePath);
+        this.get.bind(this);
+        this.post.bind(this);
+        this.put.bind(this);
+        this.delete.bind(this);
+        this.all.bind(this);
+        this.#routeAddTriNode.bind(this);
+        this.addRouter.bind(this);
+        this.group.bind(this);
+    }
+    static(...args) {
+        let route = "";
+        let dir;
+        let options = {};
+        switch (args.length) {
+            case 3:
+                [route, dir, options] = args;
+                break;
+            case 2:
+                if (typeof args[1] === "object") {
+                    [dir, options] = args;
+                }
+                else {
+                    [route, dir] = args;
+                }
+                break;
+            case 1:
+                [dir] = args;
+                break;
+            default:
+                throw new Error(`\x1b[1;31m404 Not Found\x1b[0m \x1b[1;32mInvalid arguments\x1b[0m`);
+        }
+        getFiles(dir, route, this, options);
+        return this;
+    }
+    get(path, ...args) {
+        this.#registerRoute("GET", path, ...args);
+        return this;
+    }
+    post(path, ...args) {
+        this.#registerRoute("POST", path, ...args);
+        return this;
+    }
+    put(path, ...args) {
+        this.#registerRoute("PUT", path, ...args);
+        return this;
+    }
+    patch(path, ...args) {
+        this.#registerRoute("PATCH", path, ...args);
+        return this;
+    }
+    delete(path, ...args) {
+        this.#registerRoute("DELETE", path, ...args);
+        return this;
+    }
+    options(path, ...args) {
+        this.#registerRoute("OPTIONS", path, ...args);
+        return this;
+    }
+    head(path, ...args) {
+        this.#registerRoute("HEAD", path, ...args);
+        return this;
+    }
+    all(path, ...args) {
+        this.#registerRoute("ALL", path, ...args);
+        return this;
+    }
+    addRoute(method, path, ...args) {
+        this.#registerRoute(method, path, ...args);
+        return this;
+    }
+    addRouter(path, router) {
+        return this.#routeAddTriNode(path, router);
+    }
+    group(prefix, callback) {
+        const router = new Router({
+            basePath: prefix,
+        });
+        callback(router);
+        this.#routeAddTriNode("/", router);
+        return this;
+    }
+    use(...args) {
+        let path = "/";
+        let middlewares = [];
+        let router;
+        if (typeof args[0] === "string") {
+            path = args[0];
+            if (Array.isArray(args[1])) {
+                middlewares = args[1];
+                router = args[2];
+            }
+            else if (typeof args[1] === "function") {
+                middlewares = [args[1]];
+                router = args[2];
+            }
+            else {
+                router = args[1];
+            }
+        }
+        else if (typeof args[0] === "function") {
+            if (args.length === 1) {
+                middlewares = [args[0]];
+            }
+            else {
+                middlewares = [args[0]];
+                router = args[1];
+            }
+        }
+        else if (Array.isArray(args[0])) {
+            middlewares = args[0];
+            router = args[1];
+        }
+        else if (args[0] instanceof Router) {
+            router = args[0];
+        }
+        this.#addRouteMiddleware(path, middlewares);
+        if (router && router instanceof Router) {
+            this.addRouter(path, router);
+        }
+        return this;
+    }
+    #registerRoute(method, path, ...args) {
+        if (args.length === 0) {
+            throw new Error("At least one handler is required.");
+        }
+        let middlewares = [];
+        let callback;
+        if (args.length > 1) {
+            if (Array.isArray(args[0])) {
+                middlewares = args[0];
+            }
+            else if (typeof args[0] === "function") {
+                middlewares = [args[0]];
+            }
+            callback = args[args.length - 1];
+        }
+        else {
+            callback = args[0];
+        }
+        if (typeof callback !== "function") {
+            throw new Error("Route callback function is missing or invalid.");
+        }
+        if (!middlewares.every((middleware) => typeof middleware === "function")) {
+            throw new Error("Middleware must be a function or an array of functions.");
+        }
+        this.#addRoute(method, path, callback, middlewares);
+    }
+    #addRoute(method, path, callback, middlewares) {
+        const parts = sanitizePathSplit(this.basePath, path);
+        let finalMiddleware = middlewares;
+        if (!GlobalConfig.allowDuplicateMw) {
+            finalMiddleware = new Set(middlewares);
+        }
+        let p = parts.join("/");
+        if (/(\/\*|\?)/.test(p)) {
+            let handler = this.routers.get(p);
+            if (!handler) {
+                handler = new Map();
+                handler.set(method, {
+                    callback: callback,
+                    middlewares: finalMiddleware,
+                });
+                return this.routers.set(p, handler);
+            }
+            if (!GlobalConfig.overwriteMethod && handler.has(method))
+                return;
+            return handler.set(method, { callback, middlewares: finalMiddleware });
+        }
+        let node = this.triRouter;
+        for (const part of parts) {
+            if (part.startsWith(":")) {
+                if (!node.children.has(":")) {
+                    node.children.set(":", new TrieRouter());
+                }
+                node = node.children.get(":");
+                node.isParam = true;
+                if (!node.paramName) {
+                    node.paramName = part.slice(1);
+                }
+            }
+            else {
+                if (!node.children.has(part)) {
+                    node.children.set(part, new TrieRouter());
+                }
+                node = node.children.get(part);
+            }
+        }
+        if (!GlobalConfig.overwriteMethod && node.handlers.has(method))
+            return;
+        node.handlers.set(method, {
+            callback: callback,
+            middlewares: finalMiddleware,
+        });
+        node.pathname = path;
+    }
+    #addRouteMiddleware(path, middlewareFunctions) {
+        this.addMiddleware(path, middlewareFunctions);
+    }
+    #routeAddTriNode(path, router) {
+        this.env = { ...this.env, ...router.env };
+        if (!(router instanceof Router)) {
+            throw new Error("Router instance is required.");
+        }
+        const parts = sanitizePathSplit(this.basePath, path);
+        if (router.routers.size) {
+            for (const [segment, handlers] of router.routers) {
+                let path = parts.length ? parts.join("/") + "/" + segment : segment;
+                if (this.routers.has(path)) {
+                    const baseRouter = this.routers.get(path);
+                    for (const [method, handler] of handlers) {
+                        if (!GlobalConfig.overwriteMethod && baseRouter.has(method))
+                            return;
+                        baseRouter.set(method, handler);
+                    }
+                }
+                else {
+                    this.routers.set(path, new Map(handlers));
+                }
+            }
+        }
+        let rootNode = this.triRouter;
+        let rootMiddlewares = this.triMiddlewares;
+        if (parts.length == 0) {
+            this.#addMiddlewareHandlerIDsTriNode(rootNode, rootMiddlewares, router);
+        }
+        else {
+            for (const part of parts) {
+                if (part.startsWith(":")) {
+                    if (!rootNode.children.has(":")) {
+                        rootNode.children.set(":", new TrieRouter());
+                    }
+                    rootNode = rootNode.children.get(":");
+                    rootNode.isParam = true;
+                    if (!rootNode.paramName) {
+                        rootNode.paramName = part.slice(1);
+                    }
+                }
+                else {
+                    if (!rootNode.children.has(part)) {
+                        rootNode.children.set(part, new TrieRouter());
+                    }
+                    rootNode = rootNode.children.get(part);
+                }
+            }
+            for (const part of parts) {
+                if (part.startsWith("*")) {
+                    if (!rootMiddlewares.children.has("*")) {
+                        rootMiddlewares.children.set("*", new TriMiddleware());
+                    }
+                    rootMiddlewares = rootMiddlewares.children.get("*");
+                }
+                else if (part.startsWith(":")) {
+                    const isOptional = part?.endsWith("?");
+                    if (isOptional) {
+                        rootMiddlewares.isOptional = isOptional;
+                        continue;
+                    }
+                    if (!rootMiddlewares.children.has(":")) {
+                        rootMiddlewares.children.set(":", new TriMiddleware());
+                    }
+                    rootMiddlewares = rootMiddlewares.children.get(":");
+                }
+                else {
+                    if (!rootMiddlewares.children.has(part)) {
+                        rootMiddlewares.children.set(part, new TriMiddleware());
+                    }
+                    rootMiddlewares = rootMiddlewares.children.get(part);
+                }
+            }
+            this.#addMiddlewareHandlerIDsTriNode(rootNode, rootMiddlewares, router);
+        }
+    }
+    #addMiddlewareHandlerIDsTriNode(rootNode, rootMiddlewares, router) {
+        function addSubRouter(children, node) {
+            let rtN = node;
+            for (const element of children) {
+                const pathSegment = element[0];
+                const subRouter = element[1];
+                if (rtN.children.has(pathSegment)) {
+                    let findNode = rtN.children.get(pathSegment);
+                    for (const [method, handlers] of subRouter.handlers) {
+                        if (!GlobalConfig.overwriteMethod && node.handlers.has(method))
+                            return;
+                        findNode.handlers.set(method, handlers);
+                    }
+                    if (subRouter.children.size) {
+                        addSubRouter(subRouter.children, findNode);
+                    }
+                }
+                else {
+                    rtN.children.set(pathSegment, subRouter);
+                }
+            }
+        }
+        let routerNode = router.triRouter;
+        const routerMiddlewares = router.triMiddlewares;
+        for (const [method, handlers] of routerNode.handlers) {
+            if (!GlobalConfig.overwriteMethod) {
+                rootNode.handlers.set(method, handlers);
+                continue;
+            }
+            if (!rootNode.handlers.has(method)) {
+                rootNode.handlers.set(method, handlers);
+            }
+        }
+        if (routerNode.children.size > 0) {
+            addSubRouter(routerNode.children, rootNode);
+        }
+        function addMiddleware(children, node) {
+            let n = node;
+            for (const [path, middlewareNode] of children) {
+                if (n.children.has(path)) {
+                    let findNode = n.children.get(path);
+                    if (GlobalConfig.allowDuplicateMw) {
+                        findNode.middlewares.push(...middlewareNode.middlewares);
+                    }
+                    else {
+                        for (const mw of middlewareNode.middlewares) {
+                            if (findNode.middlewares.has(mw)) {
+                                middlewareNode.middlewares.delete(mw);
+                            }
+                            findNode.middlewares.add(mw);
+                        }
+                    }
+                    if (middlewareNode.children.size) {
+                        addMiddleware(middlewareNode.children, findNode);
+                    }
+                }
+                else {
+                    n.children.set(path, middlewareNode);
+                }
+            }
+        }
+        if (GlobalConfig.allowDuplicateMw) {
+            rootMiddlewares.middlewares.push(...routerMiddlewares.middlewares);
+        }
+        else {
+            for (const mw of routerMiddlewares.middlewares) {
+                if (rootMiddlewares.middlewares.has(mw)) {
+                    routerMiddlewares.middlewares.delete(mw);
+                }
+                rootMiddlewares.middlewares.add(mw);
+            }
+        }
+        if (routerMiddlewares.children.size > 0) {
+            addMiddleware(routerMiddlewares.children, rootMiddlewares);
+        }
+    }
+}

package/server.d.ts

@@ -0,0 +1,54 @@
+import { HTTPMethod } from "./request";
+import { Middleware, Router, RouterConfig } from "./router";
+interface ServeResponse {
+    status: number;
+    headers: {
+        [key: string]: string;
+    };
+    body: string;
+    statusText: string;
+}
+export type TezXConfig = {
+    /**
+     * `allowDuplicateMw` determines whether duplicate middleware functions
+     * are allowed in the router.
+     *
+     * - When `true`: The same middleware can be added multiple times.
+     * - When `false`: Ensures each middleware is registered only once
+     *   per route or application context.
+     *
+     * @default false
+     */
+    allowDuplicateMw?: boolean;
+    /**
+     * `overwriteMethod` controls whether existing route handlers
+     * should be overwritten when a new handler for the same
+     * HTTP method and path is added.
+     *
+     * - When `true`: The new handler replaces the existing one.
+     * - When `false`: Prevents overwriting, ensuring that the
+     *   first registered handler remains active.
+     *
+     * @default true
+     */
+    overwriteMethod?: boolean;
+    /**
+     * 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;
+export declare class TezX<T extends Record<string, any> = {}> extends Router<T> {
+    #private;
+    constructor({ basePath, env, debugMode, allowDuplicateMw, overwriteMethod, }?: TezXConfig);
+    protected findRoute(method: HTTPMethod, pathname: string): {
+        callback: any;
+        middlewares: Middleware<T>[];
+        params: Record<string, string>;
+    } | null;
+    serve(req: Request, connInfo: any): Promise<ServeResponse | any>;
+}
+export {};

package/server.js

@@ -0,0 +1,166 @@
+import { GlobalConfig } from "./config/config";
+import { Context, httpStatusMap } from "./context";
+import { Router } from "./router";
+import { COLORS } from "./utils/colors";
+import { useParams } from "./utils/params";
+export class TezX extends Router {
+    constructor({ basePath = "/", env = {}, debugMode = false, allowDuplicateMw = false, overwriteMethod = true, } = {}) {
+        GlobalConfig.allowDuplicateMw = allowDuplicateMw;
+        GlobalConfig.overwriteMethod = overwriteMethod;
+        if (debugMode) {
+            GlobalConfig.debugMode = debugMode;
+        }
+        super({ basePath, env });
+        this.serve = this.serve.bind(this);
+    }
+    #hashRouter(method, pathname) {
+        const routers = this.routers;
+        for (let pattern of this.routers.keys()) {
+            const { success, params } = useParams({
+                path: pathname,
+                urlPattern: pattern,
+            });
+            const handlers = routers.get(pattern)?.get(method) || routers.get(pattern)?.get("ALL");
+            if (success && handlers) {
+                return {
+                    callback: handlers.callback,
+                    middlewares: handlers.middlewares,
+                    params: params,
+                };
+            }
+        }
+        return null;
+    }
+    #triRouter(method, pathname) {
+        const parts = pathname.split("/").filter(Boolean);
+        const params = {};
+        let node = this.triRouter;
+        for (let part of parts) {
+            if (node.children.has(part)) {
+                node = node.children.get(part);
+            }
+            else if (node.children.has(":")) {
+                node = node.children.get(":");
+                if (node.paramName)
+                    params[node.paramName] = part;
+            }
+            else {
+                return null;
+            }
+        }
+        if (node?.handlers?.size && node?.pathname) {
+            const handlers = node.handlers.get(method) || node.handlers.get("ALL");
+            if (handlers) {
+                return {
+                    middlewares: handlers.middlewares,
+                    callback: handlers.callback,
+                    params: params,
+                };
+            }
+            return null;
+        }
+        return null;
+    }
+    findRoute(method, pathname) {
+        const route = this.#triRouter(method, pathname) || this.#hashRouter(method, pathname);
+        if (route) {
+            return {
+                ...route,
+                middlewares: [...route.middlewares],
+            };
+        }
+        return null;
+    }
+    #createHandler(middlewares, finalCallback) {
+        return async (ctx) => {
+            let index = 0;
+            const next = async () => {
+                if (index < middlewares.length) {
+                    return await middlewares[index++](ctx, next);
+                }
+                else {
+                    return await finalCallback(ctx);
+                }
+            };
+            const response = await next();
+            if (!response) {
+                throw new Error(`Handler did not return a response or next() was not called. Path: ${ctx.pathname}, Method: ${ctx.method}`);
+            }
+            return response;
+        };
+    }
+    #findMiddleware(pathname) {
+        const parts = pathname.split("/").filter(Boolean);
+        let middlewares = [];
+        let node = this.triMiddlewares;
+        for (let part of parts) {
+            if (node.children.has(part)) {
+                node = node.children.get(part);
+            }
+            else if (node.children.has("*")) {
+                node = node.children.get("*");
+            }
+            else if (node.children.has(":")) {
+                node = node.children.get(":");
+            }
+            else {
+                break;
+            }
+            middlewares.push(...node.middlewares);
+        }
+        return middlewares;
+    }
+    async #handleRequest(req, connInfo) {
+        let ctx = new Context(req, connInfo);
+        const urlRef = ctx.req.urlRef;
+        const { pathname } = urlRef;
+        let middlewares = this.#findMiddleware(pathname);
+        ctx.env = this.env;
+        try {
+            let callback = async (ctx) => {
+                const find = this.findRoute(ctx.req.method, pathname);
+                if (find?.callback) {
+                    ctx.params = find.params;
+                    const callback = find.callback;
+                    let middlewares = find.middlewares;
+                    return (await this.#createHandler(middlewares, callback)(ctx));
+                }
+                else {
+                    let res = await GlobalConfig.notFound(ctx);
+                    ctx.setStatus = res.status;
+                    return res;
+                }
+            };
+            let response = await this.#createHandler([...this.triMiddlewares.middlewares, ...middlewares], callback)(ctx);
+            let finalResponse = () => {
+                return (ctx) => {
+                    if (response?.headers) {
+                        ctx.headers.add(response.headers);
+                    }
+                    const statusText = response?.statusText || httpStatusMap[response?.status] || "";
+                    const status = response.status || ctx.getStatus;
+                    let headers = ctx.headers.toObject();
+                    return new Response(response.body, {
+                        status,
+                        statusText,
+                        headers,
+                    });
+                };
+            };
+            return finalResponse()(ctx);
+        }
+        catch (err) {
+            let error = err;
+            if (err instanceof Error) {
+                error = err.stack;
+            }
+            GlobalConfig.debugging.error(`${COLORS.bgRed} ${ctx.pathname}, Method: ${ctx.method} ${COLORS.reset}`, `${httpStatusMap[500]}: ${error} `);
+            let res = await GlobalConfig.onError(error, ctx);
+            ctx.setStatus = res.status;
+            return res;
+        }
+    }
+    async serve(req, connInfo) {
+        return this.#handleRequest(req, connInfo);
+    }
+}

package/utils/colors.d.ts

@@ -0,0 +1,21 @@
+export declare const COLORS: {
+    reset: string;
+    bold: string;
+    underline: string;
+    gray: string;
+    white: string;
+    black: string;
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    bgRed: string;
+    bgGreen: string;
+    bgYellow: string;
+    bgBlue: string;
+    bgMagenta: string;
+    bgCyan: string;
+    bgWhite: string;
+};

package/utils/colors.js

@@ -0,0 +1,21 @@
+export const COLORS = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    underline: "\x1b[4m",
+    gray: "\x1b[90m",
+    white: "\x1b[97m",
+    black: "\x1b[30m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    bgRed: "\x1b[41m",
+    bgGreen: "\x1b[42m",
+    bgYellow: "\x1b[43m",
+    bgBlue: "\x1b[44m",
+    bgMagenta: "\x1b[45m",
+    bgCyan: "\x1b[46m",
+    bgWhite: "\x1b[47m",
+};

package/utils/debugging.d.ts

@@ -0,0 +1,7 @@
+export type LogLevel = "info" | "warn" | "error" | "debug" | "success";
+export declare const loggerOutput: (level: LogLevel, message: string, ...args: unknown[]) => void;
+/**
+ * A universal logger function that measures and logs the processing time of an operation.
+ * @param label - A label to identify the operation being logged.
+ * @param callback - The operation to measure and execute.
+ */

package/utils/debugging.js

@@ -0,0 +1,13 @@
+import { COLORS } from "./colors";
+export const loggerOutput = (level, message, ...args) => {
+    const timestamp = new Date().toISOString();
+    const LEVEL_COLORS = {
+        info: COLORS.blue,
+        warn: COLORS.yellow,
+        error: COLORS.red,
+        debug: COLORS.cyan,
+        success: COLORS.green,
+    };
+    const levelText = `${LEVEL_COLORS[level]}[${level.toUpperCase()}]${COLORS.reset}`;
+    console.log(` ${levelText} ${message}`, ...args?.flat());
+};

package/utils/formData.d.ts

@@ -0,0 +1,5 @@
+import { FormDataOptions } from "../request";
+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 parseMultipartBody(req: any, boundary: string, options?: FormDataOptions): Promise<Record<string, any>>;