tezx 1.0.21 → 1.0.23

package/.gitignore

@@ -0,0 +1,22 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# production
+/build
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# local env files
+.env*.local
+
+

package/.npmignore

@@ -0,0 +1,18 @@
+# Ignore all .ts files except .d.ts files
+*.ts
+
+# Optional: Allow specific .ts files if needed
+# !/specific-directory/*.ts
+/test
+/query
+/utilities
+/docs
+/dist/test
+/src
+/dist/DataTypes
+!/dist/index.d.ts
+*.md
+!README.md
+tsconfig.json
+.npmignore
+.gitignore

package/MiddlewareConfigure.d.ts

@@ -0,0 +1,17 @@
+import { CommonHandler } from "./common";
+import { Middleware } from "./router";
+export type DuplicateMiddlewares = Middleware<any>[];
+export type UniqueMiddlewares = Set<Middleware<any>>;
+export declare class TriMiddleware {
+    children: Map<string, TriMiddleware>;
+    middlewares: DuplicateMiddlewares | UniqueMiddlewares;
+    isOptional: boolean;
+    pathname: string;
+    constructor(pathname?: string);
+}
+export default class MiddlewareConfigure<T extends Record<string, any> = {}> extends CommonHandler {
+    triMiddlewares: TriMiddleware;
+    protected basePath: string;
+    constructor(basePath?: string);
+    protected addMiddleware(pathname: string, middlewares: Middleware<T>[]): void;
+}

package/MiddlewareConfigure.js

@@ -0,0 +1,63 @@
+import { CommonHandler } from "./common";
+import { GlobalConfig } from "./config/config";
+import { sanitizePathSplit } from "./utils/url";
+export class TriMiddleware {
+    children = new Map();
+    middlewares = new Set();
+    isOptional = false;
+    pathname;
+    constructor(pathname = "/") {
+        this.pathname = pathname;
+        if (GlobalConfig.allowDuplicateMw) {
+            this.middlewares = [];
+        }
+        else {
+            this.middlewares = new Set();
+        }
+    }
+}
+export default class MiddlewareConfigure extends CommonHandler {
+    triMiddlewares = new TriMiddleware();
+    basePath;
+    constructor(basePath = "/") {
+        super();
+        this.basePath = basePath;
+    }
+    addMiddleware(pathname, middlewares) {
+        const parts = sanitizePathSplit(this.basePath, pathname);
+        let node = this.triMiddlewares;
+        for (const part of parts) {
+            if (part.startsWith("*")) {
+                if (!node.children.has("*")) {
+                    node.children.set("*", new TriMiddleware());
+                }
+                node = node.children.get("*");
+            }
+            else if (part.startsWith(":")) {
+                const isOptional = part?.endsWith("?");
+                if (isOptional) {
+                    node.isOptional = isOptional;
+                    continue;
+                }
+                if (!node.children.has(":")) {
+                    node.children.set(":", new TriMiddleware());
+                }
+                node = node.children.get(":");
+            }
+            else {
+                if (!node.children.has(part)) {
+                    node.children.set(part, new TriMiddleware());
+                }
+                node = node.children.get(part);
+            }
+        }
+        if (GlobalConfig.allowDuplicateMw) {
+            node.middlewares.push(...middlewares);
+        }
+        else {
+            for (const middleware of middlewares) {
+                node.middlewares.add(middleware);
+            }
+        }
+    }
+}

package/adapter.d.ts

@@ -0,0 +1,10 @@
+import { TezX } from "./server";
+export declare function denoAdapter<T extends Record<string, any> = {}>(TezX: TezX<T>): {
+    listen: (port: number, callback?: (message: string) => void) => any;
+};
+export declare function bunAdapter<T extends Record<string, any> = {}>(TezX: TezX<T>): {
+    listen: (port: number, callback?: (message: string) => void) => any;
+};
+export declare function nodeAdapter<T extends Record<string, any> = {}>(TezX: TezX<T>): {
+    listen: (port: number, callback?: (message: string) => void) => void;
+};

package/adapter.js

@@ -0,0 +1,162 @@
+import { GlobalConfig } from "./config/config";
+export function denoAdapter(TezX) {
+    function listen(port, callback) {
+        const isDeno = typeof Deno !== "undefined";
+        try {
+            async function handleRequest(req, connInfo) {
+                let remoteAddr = connInfo.remoteAddr;
+                let localAddr = { ...server.addr };
+                let address = {
+                    remoteAddr: {
+                        port: remoteAddr?.port,
+                        address: remoteAddr?.hostname,
+                        transport: remoteAddr?.transport,
+                        family: remoteAddr?.family,
+                    },
+                    localAddr: {
+                        port: localAddr?.port,
+                        address: localAddr?.hostname,
+                        transport: localAddr?.transport,
+                        family: localAddr?.family,
+                    },
+                };
+                const response = await TezX.serve(req, address);
+                if (response instanceof Response) {
+                    return response;
+                }
+                else {
+                    return new Response(response.body, {
+                        status: response.status,
+                        statusText: response.statusText || "",
+                        headers: new Headers(response.headers),
+                    });
+                }
+            }
+            const server = isDeno ? Deno.serve({ port }, handleRequest) : null;
+            GlobalConfig.serverInfo = server;
+            if (!server) {
+                throw new Error("Deno is not find");
+            }
+            const protocol = "\x1b[1;34mhttp\x1b[0m";
+            const message = `\x1b[1m🚀 Deno TezX Server running at ${protocol}://localhost:${port}/\x1b[0m`;
+            if (typeof callback === "function") {
+                callback(message);
+            }
+            else {
+                GlobalConfig.debugging.success(message);
+            }
+            return server;
+        }
+        catch (err) {
+            throw new Error(err?.message);
+        }
+    }
+    return {
+        listen,
+    };
+}
+export function bunAdapter(TezX) {
+    function listen(port, callback) {
+        const serve = typeof Bun !== "undefined" ? Bun.serve : null;
+        try {
+            if (!serve) {
+                throw new Error("Bun is not find");
+            }
+            const server = serve({
+                port: port,
+                async fetch(req) {
+                    const response = await TezX.serve(req, {
+                        remoteAddr: server.requestIP(req),
+                        localAddr: server.address,
+                    });
+                    if (response instanceof Response) {
+                        return response;
+                    }
+                    else {
+                        return new Response(response.body, {
+                            status: response.status,
+                            statusText: response.statusText || "",
+                            headers: new Headers(response.headers),
+                        });
+                    }
+                },
+            });
+            GlobalConfig.serverInfo = server;
+            const protocol = "\x1b[1;34mhttp\x1b[0m";
+            const message = `\x1b[1m Bun TezX Server running at ${protocol}://localhost:${port}/\x1b[0m`;
+            if (typeof callback == "function") {
+                callback(message);
+            }
+            else {
+                GlobalConfig.debugging.success(message);
+            }
+            return server;
+        }
+        catch (err) {
+            throw new Error(err?.message);
+        }
+    }
+    return {
+        listen,
+    };
+}
+export function nodeAdapter(TezX) {
+    function listen(port, callback) {
+        import("http")
+            .then((r) => {
+            let server = r.createServer(async (req, res) => {
+                let address = {};
+                if (req.socket) {
+                    address = {
+                        remoteAddr: {
+                            family: req.socket.remoteFamily,
+                            address: req.socket.remoteAddress,
+                            port: req.socket.remotePort,
+                        },
+                        localAddr: {
+                            address: req.socket.localAddress,
+                            port: req.socket.localPort,
+                            family: req.socket.localFamily,
+                        },
+                    };
+                }
+                const response = await TezX.serve(req, address);
+                const statusText = response?.statusText;
+                if (!(response instanceof Response)) {
+                    throw new Error("Invalid response from TezX.serve");
+                }
+                const headers = Object.fromEntries(await response.headers.entries());
+                if (statusText) {
+                    res.statusMessage = statusText;
+                }
+                res.writeHead(response.status, headers);
+                const { Readable } = await import("stream");
+                if (response.body instanceof Readable) {
+                    response.body.pipe(res);
+                }
+                else {
+                    const body = await response.arrayBuffer();
+                    res.end(Buffer.from(body));
+                }
+            });
+            server.listen(port, () => {
+                const protocol = "\x1b[1;34mhttp\x1b[0m";
+                const message = `\x1b[1m NodeJS TezX Server running at ${protocol}://localhost:${port}/\x1b[0m`;
+                GlobalConfig.serverInfo = server;
+                if (typeof callback == "function") {
+                    callback(message);
+                }
+                else {
+                    GlobalConfig.debugging.success(message);
+                }
+                return server;
+            });
+        })
+            .catch((r) => {
+            throw Error(r.message);
+        });
+    }
+    return {
+        listen,
+    };
+}

package/common.d.ts

@@ -0,0 +1,21 @@
+import { Context } from "./context";
+import { Callback, ctx } from "./router";
+export interface option {
+    status?: number;
+}
+export type onError<T> = (error: string, ctx: Context) => void;
+export declare class CommonHandler {
+    /**
+     * Register a custom 404 handler for missing routes
+     * @param {Callback} callback - Handler function to execute when no route matches
+     * @returns {this} - Returns current instance for chaining
+     *
+     * @example
+     * // Register a custom not-found handler
+     * app.notFound((ctx) => {
+     *   ctx.status(404).text('Custom not found message');
+     * });
+     */
+    notFound(callback: Callback): this;
+    onError(callback: <T extends Record<string, any> = {}>(err: string, ctx: ctx<T>) => any): this;
+}

package/common.js

@@ -0,0 +1,11 @@
+import { GlobalConfig } from "./config/config";
+export class CommonHandler {
+    notFound(callback) {
+        GlobalConfig.notFound = callback;
+        return this;
+    }
+    onError(callback) {
+        GlobalConfig.onError = callback;
+        return this;
+    }
+}

package/config/config.d.ts

@@ -0,0 +1,17 @@
+import { Callback, ctx } from "../router";
+export declare let GlobalConfig: {
+    new (): {};
+    notFound: Callback;
+    onError: <T extends Record<string, any> = {}>(err: string, ctx: ctx<T>) => any;
+    allowDuplicateMw?: boolean;
+    overwriteMethod?: boolean;
+    debugMode?: boolean;
+    serverInfo: any;
+    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/config.js

@@ -0,0 +1,31 @@
+import { loggerOutput } from "../utils/debugging";
+export let GlobalConfig = class {
+    static notFound = (ctx) => {
+        const { method, urlRef: { pathname }, } = ctx.req;
+        return ctx.text(`${method}: '${pathname}' could not find\n`, 404);
+    };
+    static onError = (err, ctx) => {
+        return ctx.text(err, 500);
+    };
+    static allowDuplicateMw = false;
+    static overwriteMethod = true;
+    static debugMode = false;
+    static serverInfo;
+    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) => { },
+            };
+    }
+};

package/context.d.ts

@@ -0,0 +1,195 @@
+import { HeadersParser } from "./header";
+import { ConnAddress, HTTPMethod, Request } from "./request";
+import { State } from "./utils/state";
+export interface CookieOptions {
+    expires?: Date;
+    path?: string;
+    maxAge?: number;
+    domain?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: "Strict" | "Lax" | "None";
+}
+export declare const httpStatusMap: Record<number, string>;
+export type ResponseHeaders = Record<string, string>;
+export declare class Context<T extends Record<string, any> = {}> {
+    #private;
+    [key: string]: any;
+    /**
+     * Environment variables and configuration
+     * @type {object}
+     */
+    env: Record<string, any> & T;
+    /**
+     * Parser for handling and manipulating HTTP headers
+     * @type {HeadersParser}
+     */
+    headers: HeadersParser;
+    /**
+     * Parser for handling and manipulating HTTP response(Read Only)
+     * @type {Response}
+     */
+    readonly res: Response | undefined;
+    /**
+     * Request path without query parameters
+     * @type {string}
+     */
+    readonly pathname: string;
+    /**
+     * Full request URL including protocol and query string
+     * @type {string}
+     */
+    readonly url: string;
+    /**
+     * HTTP request method (GET, POST, PUT, DELETE, etc.)
+     * @type {HTTPMethod}
+     */
+    readonly method: HTTPMethod;
+    /**
+     * Public state container for application data
+     * state storage for middleware and plugins
+     * @type {State}
+     */
+    state: State;
+    constructor(req: any, connInfo: ConnAddress);
+    /**
+     * Cookie handling utility with get/set/delete operations
+     * @returns {{
+     *  get: (name: string) => string | undefined,
+     *  all: () => Record<string, string>,
+     *  delete: (name: string, options?: CookieOptions) => void,
+     *  set: (name: string, value: string, options?: CookieOptions) => void
+     * }} Cookie handling interface
+     */
+    /**
+     * Sets a header value.
+     * @param key - Header name.
+     * @param value - Header value(s).
+     */
+    header(key: string, value: string | string[]): this;
+    get cookies(): {
+        /**
+         * Get a specific cookie by name.
+         * @param {string} cookie - The name of the cookie to retrieve.
+         * @returns {string | undefined} - The cookie value or undefined if not found.
+         */
+        get: (cookie: string) => string;
+        /**
+         * Get all cookies as an object.
+         * @returns {Record<string, string>} - An object containing all cookies.
+         */
+        all: () => Record<string, string>;
+        /**
+         * Delete a cookie by setting its expiration to the past.
+         * @param {string} name - The name of the cookie to delete.
+         * @param {CookieOptions} [options] - Additional cookie options.
+         */
+        delete: (name: string, options?: CookieOptions) => void;
+        /**
+         * Set a new cookie with the given name, value, and options.
+         * @param {string} name - The name of the cookie.
+         * @param {string} value - The value of the cookie.
+         * @param {CookieOptions} [options] - Additional options like expiration.
+         */
+        set: (name: string, value: string, options?: CookieOptions) => void;
+    };
+    /**
+     * Sends a JSON response.
+     * @param body - The response data.
+     * @param status - (Optional) HTTP status code (default: 200).
+     * @param headers - (Optional) Additional response headers.
+     * @returns Response object with JSON data.
+     */
+    json(body: any, status?: number, headers?: ResponseHeaders): Response;
+    json(body: any, headers?: ResponseHeaders): Response;
+    json(body: any, status?: number): Response;
+    /**
+     * Sends a response with any content type.
+     * Automatically determines content type if not provided.
+     * @param body - The response body.
+     * @param status - (Optional) HTTP status code.
+     * @param headers - (Optional) Additional response headers.
+     * @returns Response object.
+     */
+    send(body: any, status?: number, headers?: ResponseHeaders): any;
+    send(body: any, headers?: ResponseHeaders): any;
+    send(body: any, status?: number): any;
+    /**
+     * Sends an HTML response.
+     * @param data - The HTML content as a string.
+     * @param status - (Optional) HTTP status code (default: 200).
+     * @param headers - (Optional) Additional response headers.
+     * @returns Response object with HTML data.
+     */
+    html(data: string, status?: number, headers?: ResponseHeaders): any;
+    html(data: string, headers?: ResponseHeaders): any;
+    html(data: string, status?: number): any;
+    /**
+     * Sends a plain text response.
+     * @param data - The text content.
+     * @param status - (Optional) HTTP status code (default: 200).
+     * @param headers - (Optional) Additional response headers.
+     * @returns Response object with plain text data.
+     */
+    text(data: string, status?: number, headers?: ResponseHeaders): any;
+    text(data: string, headers?: ResponseHeaders): any;
+    text(data: string, status?: number): any;
+    /**
+     * Sends an XML response.
+     * @param data - The XML content.
+     * @param status - (Optional) HTTP status code (default: 200).
+     * @param headers - (Optional) Additional response headers.
+     * @returns Response object with XML data.
+     */
+    xml(data: string, status?: number, headers?: ResponseHeaders): any;
+    xml(data: string, headers?: ResponseHeaders): any;
+    xml(data: string, status?: number): any;
+    /**
+     * HTTP status code..
+     * @param status - number.
+     * @returns Response object with context all method.
+     */
+    status: (status: number) => this;
+    set setStatus(status: number);
+    get getStatus(): number;
+    /**
+     * Redirects to a given URL.
+     * @param url - The target URL.
+     * @param status - (Optional) HTTP status code (default: 302).
+     * @returns Response object with redirect.
+     */
+    redirect(url: string, status?: number): Response;
+    /**
+     * Handles file downloads.
+     * @param filePath - The path to the file.
+     * @param fileName - The name of the downloaded file.
+     * @returns Response object for file download.
+     */
+    download(filePath: string, fileName: string): Promise<Response>;
+    /**
+     * Serves a file to the client.
+     * @param filePath - Absolute or relative path to the file.
+     * @param fileName - (Optional) The name of the send file.
+     * @param headers - (Optional) Additional headers.
+     * @returns Response object with the file stream.
+     */
+    sendFile(filePath: string, fileName?: string, headers?: ResponseHeaders): Promise<Response>;
+    sendFile(filePath: string, headers?: ResponseHeaders): Promise<Response>;
+    sendFile(filePath: string, fileName?: string): Promise<Response>;
+    /**
+     * Getter that creates a standardized Request object from internal state
+     * @returns {Request} - Normalized request object combining:
+     * - Raw platform-specific request
+     * - Parsed headers
+     * - Route parameters
+     *
+     * @example
+     * // Get standardized request
+     * const request = ctx.req;
+     * // Access route params
+     * const id = request.params.get('id');
+     */
+    get req(): Request;
+    protected set params(params: Record<string, any>);
+    protected get params(): Record<string, any>;
+}