tezx 1.0.74 → 1.0.76-beta

package/adapter/bun.d.ts

@@ -1,4 +1,33 @@
 import { TezX } from "../core/server.js";
+/**
+ * Starts the TezX server using Bun's built-in HTTP server.
+ *
+ * Supports Unix socket or TCP port, TLS options, hot reloading, error handling,
+ * WebSocket upgrade, and other Bun-specific server features.
+ *
+ * ### Usage examples:
+ * ```ts
+ * // Start server on port 3000
+ * bunAdapter(app).listen(3000, () => {
+ *   console.log("Bun server running on port 3000");
+ * });
+ *
+ * // Start Unix socket server
+ * bunAdapter(app, { unix: "/tmp/tezx.sock" }).listen();
+ *
+ * // Start server with TLS and custom error handler
+ * bunAdapter(app, {
+ *   port: 443,
+ *   tls: { certFile: "./cert.pem", keyFile: "./key.pem" },
+ *   error: (server, err) => new Response("Custom error", { status: 500 }),
+ * }).listen();
+ * ```
+ *
+ * @param {number} [port] - The TCP port number to listen on (ignored if unix socket is used).
+ * @param {(message: string) => void} [callback] - Optional callback invoked once the server starts.
+ * @returns {ReturnType<typeof Bun.serve>} Bun server instance.
+ * @throws {Error} Throws if Bun runtime is not detected.
+ */
 export declare function bunAdapter<T extends Record<string, any> = {}>(TezX: TezX<T>, options?: {
     /**
      * If set, the HTTP server will listen on a unix socket instead of a port.

package/adapter/deno.d.ts

@@ -1,4 +1,34 @@
 import { TezX } from "../core/server.js";
+/**
+ * Starts the TezX server using Deno's built-in serve APIs.
+ *
+ * Automatically selects between Unix socket and TCP server based on options.
+ * Supports TLS if TLS options are provided.
+ *
+ * ### Usage examples:
+ * ```ts
+ * // Start TCP server on port 3000
+ * denoAdapter(app).listen(3000, () => {
+ *   console.log("Server running on port 3000");
+ * });
+ *
+ * // Start Unix socket server
+ * denoAdapter(app, { transport: "unix", path: "/tmp/tezx.sock" }).listen(() => {
+ *   console.log("Server running on unix socket");
+ * });
+ *
+ * // With TLS
+ * denoAdapter(app, {
+ *   port: 443,
+ *   cert: Deno.readTextFileSync("./cert.pem"),
+ *   key: Deno.readTextFileSync("./key.pem"),
+ * }).listen();
+ * ```
+ *
+ * @param {number} [port] - TCP port number to listen on (ignored if using Unix socket).
+ * @param {(message: string) => void} [callback] - Optional callback invoked after server starts.
+ * @returns {Deno.Listener | Deno.Server | null} Returns the server instance or null if Deno runtime is not detected.
+ */
 export declare function denoAdapter<T extends Record<string, any> = {}>(TezX: TezX<T>, options?: Deno.ServeUnixOptions | Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem)): {
     listen: {
         (callback?: (message: string) => void): any;

package/adapter/index.d.ts

@@ -1,4 +1,4 @@
 export type AdapterType = "bun" | "deno" | "node";
 export * from "./bun.js";
 export * from "./deno.js";
-export * from "./node.js";
+export * from "./node/index.js";

package/adapter/index.js

@@ -1,3 +1,3 @@
 export * from "./bun.js";
 export * from "./deno.js";
-export * from "./node.js";
+export * from "./node/index.js";

package/adapter/node/index.d.ts

@@ -0,0 +1,47 @@
+import type { ServerOptions } from "node:http";
+import type { TlsOptions } from "node:tls";
+import { TezX } from "../../core/server.js";
+type UnixSocketOptions = ServerOptions & {
+    unix?: string;
+    enableSSL?: false;
+};
+type SSLOptions = ServerOptions & TlsOptions & {
+    enableSSL: true;
+};
+type TezXServerOptions = UnixSocketOptions | SSLOptions;
+/**
+ * Starts the TezX server using Node.js native `http` or `https` module based on the `enableSSL` flag.
+ * - If `enableSSL` is true and valid TLS options are provided, it uses `https.createServer`.
+ * - Otherwise, falls back to `http.createServer`.
+ * - Optionally supports binding to a Unix domain socket via `options.unix`.
+ *
+ * ### Usage:
+ *
+ * ```ts
+ * // Start with default HTTP
+ * nodeAdapter(app).listen(3000, () => {
+ *   console.log("Server is running");
+ * });
+ *
+ * // Start with HTTPS
+ * nodeAdapter(app, {
+ *   enableSSL: true,
+ *   key: fs.readFileSync("key.pem"),
+ *   cert: fs.readFileSync("cert.pem")
+ * }).listen(443);
+ *
+ * // Start with Unix socket
+ * nodeAdapter(app, { unix: "/tmp/tezx.sock" }).listen();
+ * ```
+ * @param {number} [port] - The port number to listen on (ignored if `unix` is provided).
+ * @param {() => void} [callback] - Callback invoked after the server starts listening.
+ * @returns {void} Nothing is returned directly; server instance is stored in GlobalConfig.
+ */
+export declare function nodeAdapter<T extends Record<string, any> = {}>(TezX: TezX<T>, options?: TezXServerOptions): {
+    listen: {
+        (callback?: () => void): any;
+        (port?: number): any;
+        (port?: number, callback?: () => void): any;
+    };
+};
+export {};

package/adapter/{node.js → node/index.js}

@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer";
-import { GlobalConfig } from "../core/config.js";
-import { Context } from "../core/context.js";
+import { GlobalConfig } from "../../core/config.js";
+import { Context } from "../../core/context.js";
 export function nodeAdapter(TezX, options = {}) {
     function listen(...arg) {
         let ssl = options?.enableSSL;

package/cjs/adapter/index.js

@@ -16,4 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./bun.js"), exports);
 __exportStar(require("./deno.js"), exports);
-__exportStar(require("./node.js"), exports);
+__exportStar(require("./node/index.js"), exports);

package/cjs/adapter/{node.js → node/index.js}

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodeAdapter = nodeAdapter;
 const node_buffer_1 = require("node:buffer");
-const config_js_1 = require("../core/config.js");
-const context_js_1 = require("../core/context.js");
+const config_js_1 = require("../../core/config.js");
+const context_js_1 = require("../../core/context.js");
 function nodeAdapter(TezX, options = {}) {
     function listen(...arg) {
         let ssl = options?.enableSSL;

package/cjs/core/context.js

@@ -1,82 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Context = exports.httpStatusMap = void 0;
+exports.Context = void 0;
 const state_js_1 = require("../utils/state.js");
 const staticFile_js_1 = require("../utils/staticFile.js");
-const url_js_1 = require("../utils/url.js");
+const toWebRequest_js_1 = require("../utils/toWebRequest.js");
 const config_js_1 = require("./config.js");
 const environment_js_1 = require("./environment.js");
-const header_js_1 = require("./header.js");
 const request_js_1 = require("./request.js");
-exports.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",
-};
 class Context {
-    #rawRequest;
+    rawRequest;
     env = {};
-    headers = new header_js_1.HeadersParser();
+    headers = new Headers();
     pathname;
     url;
     method;
@@ -85,30 +19,20 @@ class Context {
     #params = {};
     resBody;
     #body;
-    #urlRef;
-    #requestHeaders;
     #options;
     constructor(req, options) {
         this.#options = options;
-        this.#rawRequest = req;
         this.method = req?.method?.toUpperCase();
-        this.#requestHeaders = new header_js_1.HeadersParser(req?.headers);
         if (config_js_1.GlobalConfig.adapter == "node") {
-            let encrypted = req?.socket?.encrypted;
-            const protocol = typeof encrypted === "boolean"
-                ? encrypted
-                    ? "https"
-                    : "http"
-                : "http";
-            const host = environment_js_1.EnvironmentDetector.getHost(this.#requestHeaders);
-            const path = req.url || "/";
-            this.url = `${protocol}://${host}${path}`;
+            let request = (0, toWebRequest_js_1.toWebRequest)(req, this.method);
+            this.url = request.url;
+            this.rawRequest = request;
         }
         else {
             this.url = req.url;
+            this.rawRequest = req;
         }
-        this.#urlRef = (0, url_js_1.urlParse)(this.url);
-        this.pathname = this.#urlRef.pathname;
+        this.pathname = this.req.urlRef.pathname;
     }
     header(key, value, options) {
         let append = options?.append;
@@ -121,16 +45,9 @@ class Context {
         return this;
     }
     get cookies() {
-        const c = this.#requestHeaders.getAll("cookie");
+        const c = this.req.headers.get("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") {
+        if (typeof c == "string") {
             const cookieHeader = c.split(";");
             for (const pair of cookieHeader) {
                 const [key, value] = pair?.trim()?.split("=");
@@ -422,9 +339,8 @@ class Context {
     }
     get req() {
         return new request_js_1.Request({
-            headers: this.#requestHeaders,
-            req: this.#rawRequest,
-            urlRef: this.#urlRef,
+            method: this.method,
+            req: this.rawRequest,
             options: this.#options,
             params: this.#params,
         });

package/cjs/core/environment.js

@@ -11,13 +11,5 @@ class EnvironmentDetector {
             return "node";
         return "unknown";
     }
-    static getHost(headers) {
-        try {
-            return headers?.get("host") || "unknown";
-        }
-        catch (error) {
-            throw new Error("Failed to get host.");
-        }
-    }
 }
 exports.EnvironmentDetector = EnvironmentDetector;

package/cjs/core/request.js

@@ -2,9 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Request = void 0;
 const formData_js_1 = require("../utils/formData.js");
-const header_js_1 = require("./header.js");
+const url_js_1 = require("../utils/url.js");
 class Request {
-    #headers = new header_js_1.HeadersParser();
     url;
     method;
     urlRef = {
@@ -20,25 +19,23 @@ class Request {
     rawRequest;
     params = {};
     remoteAddress = {};
-    constructor({ headers, params, req, options, urlRef, }) {
+    constructor({ params, method, req, options, }) {
+        let parse = (0, url_js_1.urlParse)(req.url);
+        let url = parse?.href;
         this.remoteAddress = options?.connInfo?.remoteAddr;
-        this.#headers = headers;
-        this.url = urlRef.href || "";
-        this.urlRef = urlRef;
-        this.method = req?.method?.toUpperCase();
+        this.url = url || "";
+        this.urlRef = parse;
+        this.method = method;
         this.params = params;
         this.rawRequest = req;
-        this.query = urlRef.query;
+        this.query = parse.query;
     }
     get headers() {
-        let requestHeaders = this.#headers;
+        let requestHeaders = this.rawRequest.headers;
         return {
             get: function get(key) {
                 return requestHeaders.get(key.toLowerCase());
             },
-            getAll: function getAll(key) {
-                return requestHeaders.get(key.toLowerCase()) || [];
-            },
             has: function has(key) {
                 return requestHeaders.has(key.toLowerCase());
             },
@@ -51,47 +48,94 @@ class Request {
             values: function values() {
                 return requestHeaders.values();
             },
-            forEach: function forEach(callback) {
-                return requestHeaders.forEach(callback);
+            forEach: function forEach(callbackfn) {
+                return requestHeaders.forEach(callbackfn);
             },
             toJSON() {
                 return requestHeaders.toJSON();
             },
-            toObject: function toObject() {
-                return requestHeaders.toObject();
-            },
         };
     }
     async text() {
-        return await (0, formData_js_1.parseTextBody)(this.rawRequest);
+        return await this.rawRequest.text();
     }
     async json() {
-        const contentType = this.#headers.get("content-type") || "";
+        const contentType = this.rawRequest.headers.get("content-type") || "";
         if (contentType.includes("application/json")) {
-            return await (0, formData_js_1.parseJsonBody)(this.rawRequest);
+            return await this.rawRequest.json();
         }
         else {
             return {};
         }
     }
     async formData(options) {
-        const contentType = this.#headers.get("content-type") || "";
+        const contentType = this.rawRequest.headers.get("content-type") || "";
         if (!contentType) {
             throw Error("Invalid Content-Type");
         }
         if (contentType.includes("application/json")) {
-            return await (0, formData_js_1.parseJsonBody)(this.rawRequest);
+            return await this.rawRequest.json();
         }
         else if (contentType.includes("application/x-www-form-urlencoded")) {
-            return (0, formData_js_1.parseUrlEncodedBody)(this.rawRequest);
+            const formData = await this.rawRequest.formData();
+            const result = {};
+            for (const [key, value] of formData.entries()) {
+                result[key] = value;
+            }
+            return result;
         }
         else if (contentType.includes("multipart/form-data")) {
             const boundaryMatch = contentType.match(/boundary=([^;]+)/);
             if (!boundaryMatch) {
                 throw new Error("Boundary not found in multipart/form-data");
             }
-            const boundary = boundaryMatch[1];
-            return await (0, formData_js_1.parseMultipartBody)(this.rawRequest, boundary, options);
+            const formData = await this.rawRequest.formData();
+            const result = {};
+            for (const [key, value] of formData.entries()) {
+                let val = value;
+                if (val instanceof File && typeof options == "object") {
+                    let filename = val.name;
+                    if (options?.sanitized) {
+                        filename = `${Date.now()}-${(0, formData_js_1.sanitized)(filename)}`;
+                    }
+                    if (Array.isArray(options?.allowedTypes) &&
+                        !options.allowedTypes?.includes(val.type)) {
+                        throw new Error(`Invalid file type: "${val.type}". Allowed types: ${options.allowedTypes.join(", ")}`);
+                    }
+                    if (typeof options?.maxSize !== "undefined" &&
+                        val.size > options.maxSize) {
+                        throw new Error(`File size exceeds the limit: ${val.size} bytes (Max: ${options.maxSize} bytes)`);
+                    }
+                    if (typeof options?.maxFiles != "undefined" && options.maxFiles == 0) {
+                        throw new Error(`Field "${key}" exceeds the maximum allowed file count of ${options.maxFiles}.`);
+                    }
+                    val = new File([await val.arrayBuffer()], filename, {
+                        type: val.type,
+                    });
+                }
+                if (result[key]) {
+                    if (Array.isArray(result[key])) {
+                        if (val instanceof File &&
+                            typeof options?.maxFiles != "undefined" &&
+                            result[key]?.length >= options.maxFiles) {
+                            throw new Error(`Field "${key}" exceeds the maximum allowed file count of ${options.maxFiles}.`);
+                        }
+                        result[key].push(val);
+                    }
+                    else {
+                        if (val instanceof File &&
+                            typeof options?.maxFiles != "undefined" &&
+                            options.maxFiles == 1) {
+                            throw new Error(`Field "${key}" exceeds the maximum allowed file count of ${options.maxFiles}.`);
+                        }
+                        result[key] = [result[key], val];
+                    }
+                }
+                else {
+                    result[key] = val;
+                }
+            }
+            return result;
         }
         else {
             return {};

package/cjs/core/router.js

@@ -63,6 +63,11 @@ class Router extends MiddlewareConfigure_js_1.default {
         this.#registerRoute("GET", path, ...args);
         return this;
     }
+    sse(path, handler) {
+        this.get(path, async (ctx) => {
+            return handler(ctx);
+        });
+    }
     post(path, ...args) {
         this.#registerRoute("POST", path, ...args);
         return this;

package/cjs/core/server.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TezX = void 0;
 const colors_js_1 = require("../utils/colors.js");
+const httpStatusMap_js_1 = require("../utils/httpStatusMap.js");
 const params_js_1 = require("../utils/params.js");
 const config_js_1 = require("./config.js");
 const context_js_1 = require("./context.js");
@@ -197,12 +198,12 @@ class TezX extends router_js_1.Router {
             }
             let finalResponse = () => {
                 return (ctx) => {
-                    if (response?.headers) {
-                        ctx.headers.add(response.headers);
+                    for (const [key, value] of response?.headers.entries()) {
+                        ctx.headers.set(key, value);
                     }
-                    const statusText = response?.statusText || context_js_1.httpStatusMap[response?.status] || "";
+                    const statusText = response?.statusText || httpStatusMap_js_1.httpStatusMap[response?.status] || "";
                     const status = response.status || ctx.getStatus;
-                    let headers = ctx.headers.toObject();
+                    let headers = ctx.headers.toJSON();
                     return new Response(response.body, {
                         status,
                         statusText,
@@ -221,7 +222,7 @@ class TezX extends router_js_1.Router {
         if (err instanceof Error) {
             error = err.stack;
         }
-        config_js_1.GlobalConfig.debugging.error(`${colors_js_1.COLORS.bgRed} ${ctx.pathname}, Method: ${ctx.method} ${colors_js_1.COLORS.reset}`, `${context_js_1.httpStatusMap[500]}: ${error} `);
+        config_js_1.GlobalConfig.debugging.error(`${colors_js_1.COLORS.bgRed} ${ctx.pathname}, Method: ${ctx.method} ${colors_js_1.COLORS.reset}`, `${httpStatusMap_js_1.httpStatusMap[500]}: ${error} `);
         let res = await config_js_1.GlobalConfig.onError(error, ctx);
         ctx.setStatus = res.status;
         return res;

package/cjs/index.js

@@ -7,4 +7,4 @@ var server_js_1 = require("./core/server.js");
 Object.defineProperty(exports, "TezX", { enumerable: true, get: function () { return server_js_1.TezX; } });
 var params_js_1 = require("./utils/params.js");
 Object.defineProperty(exports, "useParams", { enumerable: true, get: function () { return params_js_1.useParams; } });
-exports.version = "1.0.74";
+exports.version = "1.0.76-beta";

package/cjs/middleware/cors.js

@@ -41,7 +41,7 @@ function cors(option = {}) {
         if (ctx.req.method === "OPTIONS") {
             return new Response(null, {
                 status: 204,
-                headers: ctx.headers.toObject(),
+                headers: ctx.headers.toJSON(),
             });
         }
         return await next();

package/cjs/middleware/sanitizeHeader.js

@@ -31,9 +31,9 @@ const sanitizeHeaders = (options = {}) => {
                 config_js_1.GlobalConfig.debugging.warn(`⚠️ All values for "${normalizedKey}" invalid - removed`);
                 continue;
             }
-            sanitizedHeaders.set(normalizedKey, sanitizedValues);
+            sanitizedHeaders.set(normalizedKey, sanitizedValues?.join(", "));
         }
-        ctx.headers.clear().add([...sanitizedHeaders.entries()]);
+        ctx.headers = new Headers(sanitizedHeaders);
         return await next();
     };
 };