tezx 1.0.21 → 1.0.22

package/context.js

@@ -0,0 +1,424 @@
+import { EnvironmentDetector } from "./environment";
+import { HeadersParser } from "./header";
+import { Request } from "./request";
+import { State } from "./utils/state";
+import { defaultMimeType, mimeTypes } from "./utils/staticFile";
+export const httpStatusMap = {
+    100: "Continue",
+    101: "Switching Protocols",
+    102: "Processing",
+    103: "Early Hints",
+    200: "OK",
+    201: "Created",
+    202: "Accepted",
+    203: "Non-Authoritative Information",
+    204: "No Content",
+    205: "Reset Content",
+    206: "Partial Content",
+    207: "Multi-Status",
+    208: "Already Reported",
+    226: "IM Used",
+    300: "Multiple Choices",
+    301: "Moved Permanently",
+    302: "Found",
+    303: "See Other",
+    304: "Not Modified",
+    305: "Use Proxy",
+    306: "Switch Proxy",
+    307: "Temporary Redirect",
+    308: "Permanent Redirect",
+    400: "Bad Request",
+    401: "Unauthorized",
+    402: "Payment Required",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    406: "Not Acceptable",
+    407: "Proxy Authentication Required",
+    408: "Request Timeout",
+    409: "Conflict",
+    410: "Gone",
+    411: "Length Required",
+    412: "Precondition Failed",
+    413: "Payload Too Large",
+    414: "URI Too Long",
+    415: "Unsupported Media Type",
+    416: "Range Not Satisfiable",
+    417: "Expectation Failed",
+    418: "I'm a Teapot",
+    421: "Misdirected Request",
+    422: "Unprocessable Entity",
+    423: "Locked",
+    424: "Failed Dependency",
+    425: "Too Early",
+    426: "Upgrade Required",
+    428: "Precondition Required",
+    429: "Too Many Requests",
+    431: "Request Header Fields Too Large",
+    451: "Unavailable For Legal Reasons",
+    500: "Internal Server Error",
+    501: "Not Implemented",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout",
+    505: "HTTP Version Not Supported",
+    506: "Variant Also Negotiates",
+    507: "Insufficient Storage",
+    508: "Loop Detected",
+    510: "Not Extended",
+    511: "Network Authentication Required",
+};
+export class Context {
+    #rawRequest;
+    env = {};
+    headers = new HeadersParser();
+    res;
+    pathname;
+    url;
+    method;
+    #status = 200;
+    state = new State();
+    #params = {};
+    #localAddress = {};
+    #remoteAddress = {};
+    constructor(req, connInfo) {
+        this.#rawRequest = req;
+        this.#remoteAddress = connInfo.remoteAddr;
+        this.#localAddress = connInfo.localAddr;
+        this.method = req?.method?.toUpperCase();
+        this.pathname = this.req.urlRef.pathname;
+        this.url = this.req.url;
+    }
+    header(key, value) {
+        this.headers.set(key, value);
+        return this;
+    }
+    get cookies() {
+        const c = this.headers.getAll("cookie");
+        let cookies = {};
+        if (Array.isArray(c) && c.length != 0) {
+            const cookieHeader = c.join("; ").split(";");
+            for (const pair of cookieHeader) {
+                const [key, value] = pair?.trim()?.split("=");
+                cookies[key] = decodeURIComponent(value);
+            }
+        }
+        else if (typeof c == "string") {
+            const cookieHeader = c.split(";");
+            for (const pair of cookieHeader) {
+                const [key, value] = pair?.trim()?.split("=");
+                cookies[key] = decodeURIComponent(value);
+            }
+        }
+        return {
+            get: (cookie) => {
+                return cookies?.[cookie];
+            },
+            all: () => {
+                return cookies;
+            },
+            delete: (name, options) => {
+                const value = "";
+                const cookieOptions = {
+                    ...options,
+                    expires: new Date(0),
+                };
+                const cookieHeader = `${name}=${value};${serializeOptions(cookieOptions)}`;
+                this.headers.set("Set-Cookie", cookieHeader);
+            },
+            set: (name, value, options) => {
+                const cookieHeader = `${name}=${value};${serializeOptions(options || {})}`;
+                this.headers.set("Set-Cookie", cookieHeader);
+            },
+        };
+    }
+    json(body, ...args) {
+        let status = this.#status;
+        let headers = {
+            "Content-Type": "application/json; charset=utf-8",
+        };
+        if (typeof args[0] === "number") {
+            status = args[0];
+            if (typeof args[1] === "object") {
+                headers = { ...headers, ...args[1] };
+            }
+        }
+        else if (typeof args[0] === "object") {
+            headers = { ...headers, ...args[0] };
+        }
+        return this.#handleResponse(JSON.stringify(body), {
+            status: status,
+            headers: headers,
+        });
+    }
+    send(body, ...args) {
+        let status = this.#status;
+        let headers = {};
+        if (typeof args[0] === "number") {
+            status = args[0];
+            if (typeof args[1] === "object") {
+                headers = args[1];
+            }
+        }
+        else if (typeof args[0] === "object") {
+            headers = args[0];
+        }
+        if (!headers["Content-Type"]) {
+            if (typeof body === "string") {
+                headers["Content-Type"] = "text/plain;";
+            }
+            else if (typeof body === "object" && body !== null) {
+                headers["Content-Type"] = "application/json;";
+                body = JSON.stringify(body);
+            }
+            else {
+                headers["Content-Type"] = "application/octet-stream";
+            }
+        }
+        return this.#handleResponse(body, {
+            status: status,
+            headers,
+        });
+    }
+    html(data, ...args) {
+        let status = this.#status;
+        let headers = {
+            "Content-Type": "text/html; charset=utf-8",
+        };
+        if (typeof args[0] === "number") {
+            status = args[0];
+            if (typeof args[1] === "object") {
+                headers = { ...headers, ...args[1] };
+            }
+        }
+        else if (typeof args[0] === "object") {
+            headers = { ...headers, ...args[0] };
+        }
+        return this.#handleResponse(data, {
+            status: status,
+            headers: headers,
+        });
+    }
+    text(data, ...args) {
+        let status = this.#status;
+        let headers = {
+            "Content-Type": "text/plain; charset=utf-8",
+        };
+        if (typeof args[0] === "number") {
+            status = args[0];
+            if (typeof args[1] === "object") {
+                headers = { ...headers, ...args[1] };
+            }
+        }
+        else if (typeof args[0] === "object") {
+            headers = { ...headers, ...args[0] };
+        }
+        return this.#handleResponse(data, {
+            status: status,
+            headers: headers,
+        });
+    }
+    xml(data, ...args) {
+        let status = this.#status;
+        let headers = {
+            "Content-Type": "application/xml; charset=utf-8",
+        };
+        if (typeof args[0] === "number") {
+            status = args[0];
+            if (typeof args[1] === "object") {
+                headers = { ...headers, ...args[1] };
+            }
+        }
+        else if (typeof args[0] === "object") {
+            headers = { ...headers, ...args[0] };
+        }
+        return this.#handleResponse(data, {
+            status: status,
+            headers: headers,
+        });
+    }
+    status = (status) => {
+        this.#status = status;
+        return this;
+    };
+    set setStatus(status) {
+        this.#status = status;
+    }
+    get getStatus() {
+        return this.#status;
+    }
+    redirect(url, status = 302) {
+        return new Response(null, {
+            status: status,
+            headers: { Location: url },
+        });
+    }
+    async download(filePath, fileName) {
+        try {
+            let fileExists = false;
+            const runtime = EnvironmentDetector.getEnvironment;
+            if (runtime === "node") {
+                const { existsSync } = await import("fs");
+                fileExists = existsSync(filePath);
+            }
+            else if (runtime === "bun") {
+                fileExists = Bun.file(filePath).exists();
+            }
+            else if (runtime === "deno") {
+                try {
+                    await Deno.stat(filePath);
+                    fileExists = true;
+                }
+                catch {
+                    fileExists = false;
+                }
+            }
+            if (!fileExists) {
+                throw Error("File not found");
+            }
+            let fileBuffer;
+            if (runtime === "node") {
+                const { readFileSync } = await import("fs");
+                fileBuffer = await readFileSync(filePath);
+            }
+            else if (runtime === "bun") {
+                fileBuffer = await Bun.file(filePath)
+                    .arrayBuffer()
+                    .then((buf) => new Uint8Array(buf));
+            }
+            else if (runtime === "deno") {
+                fileBuffer = await Deno.readFile(filePath);
+            }
+            return this.#handleResponse(fileBuffer, {
+                status: 200,
+                headers: {
+                    "Content-Disposition": `attachment; filename="${fileName}"`,
+                    "Content-Type": "application/octet-stream",
+                    "Content-Length": fileBuffer.byteLength.toString(),
+                },
+            });
+        }
+        catch (error) {
+            throw Error("Internal Server Error" + error?.message);
+        }
+    }
+    async sendFile(filePath, ...args) {
+        try {
+            const runtime = EnvironmentDetector.getEnvironment;
+            const resolvedPath = filePath;
+            let fileExists = false;
+            if (runtime === "node") {
+                const { existsSync } = await import("fs");
+                fileExists = existsSync(resolvedPath);
+            }
+            else if (runtime === "bun") {
+                fileExists = Bun.file(resolvedPath).exists();
+            }
+            else if (runtime === "deno") {
+                try {
+                    await Deno.stat(resolvedPath);
+                    fileExists = true;
+                }
+                catch {
+                    fileExists = false;
+                }
+            }
+            if (!fileExists) {
+                throw Error("File not found");
+            }
+            let fileSize = 0;
+            if (runtime === "node") {
+                const { statSync } = await import("fs");
+                fileSize = statSync(resolvedPath).size;
+            }
+            else if (runtime === "bun") {
+                fileSize = (await Bun.file(resolvedPath).arrayBuffer()).byteLength;
+            }
+            else if (runtime === "deno") {
+                const fileInfo = await Deno.stat(resolvedPath);
+                fileSize = fileInfo.size;
+            }
+            const ext = filePath.split(".").pop()?.toLowerCase() || "";
+            const mimeType = mimeTypes[ext] || defaultMimeType;
+            let fileStream;
+            if (runtime === "node") {
+                const { createReadStream } = await import("fs");
+                fileStream = createReadStream(resolvedPath);
+            }
+            else if (runtime === "bun") {
+                fileStream = Bun.file(resolvedPath).stream();
+            }
+            else if (runtime === "deno") {
+                const file = await Deno.open(resolvedPath, { read: true });
+                fileStream = file.readable;
+            }
+            let headers = {
+                "Content-Type": mimeType,
+                "Content-Length": fileSize.toString(),
+            };
+            let fileName = "";
+            if (typeof args[0] === "string") {
+                fileName = args[0];
+                if (typeof args[1] === "object") {
+                    headers = { ...headers, ...args[1] };
+                }
+            }
+            else if (typeof args[0] === "object") {
+                headers = { ...headers, ...args[0] };
+            }
+            if (fileName) {
+                headers["Content-Disposition"] = `attachment; filename="${fileName}"`;
+            }
+            return this.#handleResponse(fileStream, {
+                status: 200,
+                headers,
+            });
+        }
+        catch (error) {
+            throw Error("Internal Server Error" + error?.message);
+        }
+    }
+    #handleResponse(body, { headers, status }) {
+        let response = new Response(body, {
+            status: status,
+            headers,
+        });
+        let clone = response.clone();
+        this.res = response;
+        return clone;
+    }
+    get req() {
+        return new Request(this.#rawRequest, this.params, this.#remoteAddress);
+    }
+    set params(params) {
+        this.#params = params;
+    }
+    get params() {
+        return this.#params;
+    }
+}
+function serializeOptions(options) {
+    const parts = [];
+    if (options.maxAge) {
+        parts.push(`Max-Age=${options.maxAge}`);
+    }
+    if (options.expires) {
+        parts.push(`Expires=${options.expires.toUTCString()}`);
+    }
+    if (options.path) {
+        parts.push(`Path=${options.path}`);
+    }
+    if (options.domain) {
+        parts.push(`Domain=${options.domain}`);
+    }
+    if (options.secure) {
+        parts.push(`Secure`);
+    }
+    if (options.httpOnly) {
+        parts.push(`HttpOnly`);
+    }
+    if (options.sameSite) {
+        parts.push(`SameSite=${options.sameSite}`);
+    }
+    return parts.join("; ");
+}

package/environment.d.ts

@@ -0,0 +1,6 @@
+import { HeadersParser } from "./header";
+export declare class EnvironmentDetector {
+    static get getEnvironment(): "node" | "bun" | "deno" | "unknown";
+    static detectProtocol(req: any): "unknown" | "http" | "https";
+    static getHost(headers: HeadersParser): string;
+}

package/environment.js

@@ -0,0 +1,30 @@
+export class EnvironmentDetector {
+    static get getEnvironment() {
+        if (typeof Bun !== "undefined")
+            return "bun";
+        if (typeof Deno !== "undefined")
+            return "deno";
+        if (typeof process !== "undefined" && process.versions?.node)
+            return "node";
+        return "unknown";
+    }
+    static detectProtocol(req) {
+        try {
+            if (this.getEnvironment === "node") {
+                return req?.socket?.encrypted ? "https" : "http";
+            }
+            return "unknown";
+        }
+        catch (error) {
+            throw new Error("Failed to detect protocol.");
+        }
+    }
+    static getHost(headers) {
+        try {
+            return headers?.get("host") || "unknown";
+        }
+        catch (error) {
+            throw new Error("Failed to get host.");
+        }
+    }
+}

package/header.d.ts

@@ -0,0 +1,71 @@
+export declare class HeadersParser {
+    private headers;
+    constructor(init?: [string, string | string[]][] | Record<string, string>);
+    /**
+     * Adds multiple headers to the parser.
+     * @param headers - Headers as an array of tuples or a record object.
+     */
+    add(headers: [string, string | string[]][] | Record<string, string>): this;
+    /**
+     * Sets a header value.
+     * @param key - Header name.
+     * @param value - Header value(s).
+     */
+    set(key: string, value: string | string[]): this;
+    clear(): this;
+    /**
+     * Retrieves the first value of a header.
+     * @param key - Header name.
+     * @returns The first header value or undefined if not found.
+     */
+    get(key: string): string | undefined;
+    /**
+     * Retrieves all values of a header.
+     * @param key - Header name.
+     * @returns An array of header values.
+     */
+    getAll(key: string): string[];
+    /**
+     * Checks if a header exists.
+     * @param key - Header name.
+     * @returns True if the header exists, false otherwise.
+     */
+    has(key: string): boolean;
+    /**
+     * Deletes a header.
+     * @param key - Header name.
+     * @returns True if deleted successfully, false otherwise.
+     */
+    delete(key: string): boolean;
+    /**
+     * Appends a value to an existing header or creates a new one.
+     * @param key - Header name.
+     * @param value - Value to append.
+     */
+    append(key: string, value: string): this;
+    /**
+     * Returns an iterator over header entries.
+     * @returns IterableIterator of header key-value pairs.
+     */
+    entries(): IterableIterator<[string, string[]]>;
+    /**
+     * Returns an iterator over header keys.
+     * @returns IterableIterator of header names.
+     */
+    keys(): IterableIterator<string>;
+    /**
+     * Returns an iterator over header values.
+     * @returns IterableIterator of header values arrays.
+     */
+    values(): IterableIterator<string[]>;
+    /**
+     * Iterates over headers and executes a callback function.
+     * @param callback - Function to execute for each header.
+     */
+    forEach(callback: (value: string[], key: string) => void): void;
+    /**
+     * Converts headers into a plain object.
+     * @returns A record of headers where single-value headers are returned as a string.
+     */
+    toObject(): Record<string, string | string[]>;
+}

package/header.js

@@ -0,0 +1,81 @@
+export class HeadersParser {
+    headers = new Map();
+    constructor(init) {
+        if (init) {
+            this.add(init);
+        }
+    }
+    add(headers) {
+        if (Array.isArray(headers)) {
+            for (const [key, value] of headers) {
+                this.set(key, value);
+            }
+        }
+        else if (typeof Headers !== "undefined" && headers instanceof Headers) {
+            for (const [key, value] of headers.entries()) {
+                this.set(key, value);
+            }
+        }
+        else if (typeof headers === "object") {
+            for (const key in headers) {
+                if (Object.prototype.hasOwnProperty.call(headers, key)) {
+                    this.set(key, headers[key]);
+                }
+            }
+        }
+        return this;
+    }
+    set(key, value) {
+        this.headers.set(key.toLowerCase(), Array.isArray(value) ? value : [value]);
+        return this;
+    }
+    clear() {
+        this.headers.clear();
+        return this;
+    }
+    get(key) {
+        const values = this.headers.get(key.toLowerCase());
+        return values ? values[0] : undefined;
+    }
+    getAll(key) {
+        return this.headers.get(key.toLowerCase()) || [];
+    }
+    has(key) {
+        return this.headers.has(key.toLowerCase());
+    }
+    delete(key) {
+        return this.headers.delete(key.toLowerCase());
+    }
+    append(key, value) {
+        const lowerKey = key.toLowerCase();
+        if (this.headers.has(lowerKey)) {
+            this.headers.get(lowerKey).push(value);
+        }
+        else {
+            this.headers.set(lowerKey, [value]);
+        }
+        return this;
+    }
+    entries() {
+        return this.headers.entries();
+    }
+    keys() {
+        return this.headers.keys();
+    }
+    values() {
+        return this.headers.values();
+    }
+    forEach(callback) {
+        for (const [key, value] of this.headers) {
+            callback(value, key);
+        }
+    }
+    toObject() {
+        const obj = {};
+        for (const [key, value] of this.headers.entries()) {
+            obj[key] = value.length > 1 ? value : value[0];
+        }
+        return obj;
+    }
+}
+Object.defineProperty(HeadersParser, "name", { value: "Headers" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tezx",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "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",
@@ -41,11 +41,7 @@
   },
   "homepage": "https://github.com/tezxjs/TezX",
   "files": [
-    "index.js",
-    "index.d.ts",
-    "cjs/",
-    "middleware/",
-    "helper/"
+    "./**"
   ],
   "keywords": [
     "server",