tezx 2.0.11 → 3.0.0

package/README.md

@@ -1,21 +1,21 @@
-# TezX - High-Performance JavaScript Framework
+# ⚡ TezX – High-Performance JavaScript Framework
 
-**TezX** is a cutting-edge, high-performance, and lightweight JavaScript framework designed for speed, scalability, and flexibility. Built with modern web development needs in mind, TezX enables efficient routing, middleware management, and static file serving with minimal configuration. It is fully compatible with **Node.js, Deno, and Bun**, making it a truly cross-environment framework.
+**TezX** is a modern, high-performance, and lightweight JavaScript framework designed for speed, scalability, and cross-environment compatibility. It offers an intuitive API for routing, middleware management, and static file serving—making it ideal for building web applications with **Node.js**, **Deno**, and **Bun**.
 
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/tezxjs/TezX)
 
 ---
 
-## 🚀 Key Features
+## 🚀 Features at a Glance
 
-- ⚡ **High Performance** – Optimized for speed and scalability.
-- 🔥 **Minimal & Intuitive API** – Simple yet powerful.
-- 🗂️ **Built-in Static File Serving** – No additional setup required.
-- 🔌 **Robust Middleware Support** – Easily extend functionality.
-- 🧭 **Dynamic & Flexible Routing** – Define routes with ease.
-- 🔐 **Security First** – Designed with security best practices.
-- 📡 **Efficient HTTP Handling** – Built for high concurrency.
-- 🌍 **Cross-Environment Support** – Node.js, Deno, and Bun ready.
+- ⚡ **Ultra-Fast Performance** – Built for speed and concurrency.
+- 🧩 **Minimal & Intuitive API** – Clean and easy to use.
+- 🗂 **Static File Serving** – Serve files with a single command.
+- 🔌 **Middleware Support** – Stack and compose custom logic.
+- 🧭 **Flexible Routing** – Dynamic and pattern-based routing.
+- 🔐 **Security-First Design** – Secure by default.
+- 📡 **Efficient HTTP Engine** – High-concurrency request handling.
+- 🌍 **Cross-Environment** – Works with Node.js, Deno, and Bun.
 
 ---
 
@@ -25,11 +25,9 @@
 
 ```bash
 npm install tezx
-```
-
-```bash
+# or
 yarn add tezx
-````
+```
 
 ### Bun
 
@@ -42,7 +40,7 @@ bun add tezx
 
 ```ts
 import { TezX } from "https://deno.land/x/tezx/mod.ts";
-``` 
+```
 -->
 
 ---
@@ -51,58 +49,58 @@ import { TezX } from "https://deno.land/x/tezx/mod.ts";
 
 ```ts
 import { TezX } from "tezx";
-import { logger } from "tezx/middleware";
-import { nodeAdapter } from "tezx/node";
+import { logger } from "tezx/logger";
+import { createServer } from "node:http";
+import { mountTezXOnNode } from "tezx/node";
 
 const app = new TezX();
 app.use(logger());
-
 app.static("/", "./static");
 
-app.get("/", (ctx) => {
-  return ctx.html(`
+app.get("/", (ctx) =>
+  ctx.html(`
     <h1>Welcome to TezX</h1>
-    <p>A modern, high-performance cross-environment framework.</p>
-  `);
-});
+    <p>A modern, high-performance, cross-runtime JavaScript framework.</p>
+  `)
+);
+
+const server = createServer();
+mountTezXOnNode(app, server);
 
-nodeAdapter(app).listen(3001, (message) => {
-  console.log(message);
+const PORT = process.env.PORT || 3000;
+server.listen(PORT, () => {
+  console.log(`🚀 TezX is running at http://localhost:${PORT}`);
 });
 ```
 
 ---
 
-## ▶ Running the Server
+## ▶ Starting the Server
 
 ### Node.js
 
 ```bash
 node server.js
-```
-
-For development:
-
-```bash
+# or
 npm install -g nodemon
 nodemon server.js
 ```
 
-### Deno
+### Bun
 
 ```bash
-deno run --allow-net server.ts
+bun run server.js
 ```
 
-### Bun
+### Deno
 
 ```bash
-bun run server.js
+deno run --allow-all server.ts
 ```
 
 ---
 
-## 🛠 Middleware Support
+## 🔌 Middleware Usage
 
 ```ts
 app.use((ctx, next) => {
@@ -113,22 +111,24 @@ app.use((ctx, next) => {
 
 ---
 
-## 📂 Static File Serving
+## 🗂 Static File Serving
 
 ```ts
 app.static("/public", "./public");
 ```
 
-Files are accessible via `/public/filename.ext`.
+Accessible via: `http://localhost:3000/public/filename.ext`
 
 ---
 
-## 🔀 Routing
+## 🧭 Routing
 
 ```ts
 app.get("/about", (ctx) => ctx.html("<h1>About Us</h1>"));
 
-app.post("/submit", (ctx) => ctx.json({ message: "Form submitted successfully" }));
+app.post("/submit", (ctx) =>
+  ctx.json({ message: "Form submitted successfully" })
+);
 ```
 
 ---
@@ -145,72 +145,99 @@ app.onError((err, ctx) => {
 
 ## 🧪 Development Setup
 
-### Clone and Install
-
-```bash
-git clone https://github.com/tezxjs/tezx-app-example
-cd tezx-app-example
-npm install tezx@latest
-```
-
 ### Run Dev Server
 
 ```bash
 npm run dev
+# or
+bun run dev
 ```
 
-> Access at: [http://localhost:3000](http://localhost:3000)
+Access: [http://localhost:3000](http://localhost:3000)
 
 ---
 
 ## ⚙️ Platform-Specific Scripts
 
-### Node.js (Add to `package.json`)
+### Node.js – `package.json`
 
 ```json
-"scripts": {
-  "clean": "rm -rf dist",
-  "build:cjs": "tsc --module CommonJS --outDir dist/cjs --removeComments",
-  "build:esm": "tsc --module ESNext --outDir dist/mjs --removeComments",
-  "build:dts": "tsc --module ESNext --outDir dist/types --declaration --emitDeclarationOnly",
-  "build": "npm run clean && npm run build:cjs && npm run build:esm && npm run build:dts",
-  "start": "node dist/index.js",
-  "nodemon": "nodemon src/index.ts",
-  "dev": "tsx watch src/index.ts"
+{
+  "scripts": {
+    "build:esm": "tsc --outDir dist/mjs --removeComments",
+    "build:dts": "tsc --outDir dist/types --declaration --emitDeclarationOnly",
+    "build": "npm run build:esm && npm run build:dts",
+    "start": "node dist/index.js",
+    "nodemon": "nodemon src/index.ts",
+    "dev": "tsx watch src/index.ts"
+  }
 }
 ```
 
-### Bun
+---
+
+### Bun – `package.json`
 
 ```json
-"scripts": {
-  "dev": "bun run --hot --watch src/index.ts"
+{
+  "scripts": {
+    "dev": "bun run --hot --watch src/index.ts"
+  }
 }
 ```
 
-`src/index.ts`:
+#### Example: `src/index.ts`
 
 ```ts
-import { bunAdapter } from "tezx/bun";
-bunAdapter(app).listen(3000, (message) => {
-  console.log(message);
+Bun.serve({
+  port: 3001,
+  reusePort: true,
+  fetch(req, server) {
+    return app.serve(req, server);
+  },
+  websocket: {
+    open(ws) {
+      console.log("WebSocket connected");
+      return ws.data?.open?.(ws);
+    },
+    message(ws, msg) {
+      return ws.data?.message?.(ws, msg);
+    },
+    close(ws, code, reason) {
+      return ws.data?.close?.(ws, { code, reason });
+    },
+    ping(ws, data) {
+      return ws.data?.ping?.(ws, data);
+    },
+    pong(ws, data) {
+      return ws.data?.pong?.(ws, data);
+    },
+    drain(ws) {
+      return ws.data?.drain?.(ws);
+    }
+  }
 });
+
+console.log(`🚀 Server running at http://localhost:${process.env.PORT}`);
 ```
 
-### Deno
+---
+
+### Deno – `package.json`
 
 ```json
-"scripts": {
-  "dev": "deno run --watch --allow-net --allow-read --allow-env --unstable-sloppy-imports src/index.ts"
+{
+  "scripts": {
+    "dev": "deno run --watch --allow-all --unstable-sloppy-imports src/index.ts"
+  }
 }
 ```
 
-`src/index.ts`:
+#### Example: `src/index.ts`
 
 ```ts
-import { denoAdapter } from "tezx/deno";
-denoAdapter(app).listen(3000, (message) => {
-  console.log(message);
+Deno.serve({ port: Number(Deno.env.get("PORT") || 5000) }, (req, connInfo) => {
+  return app.serve(req, connInfo);
 });
 ```
 
@@ -218,39 +245,47 @@ denoAdapter(app).listen(3000, (message) => {
 
 ## 🏗 Build & Deployment
 
-### Compile TypeScript to JavaScript
-
-Using `tsc`:
+### Compile TypeScript
 
 ```bash
 npm run build
 ```
 
+Outputs:
+
+- CommonJS (`dist/cjs`)
+- ESM (`dist/mjs`)
+- Type Declarations (`dist/types`)
+
 ---
 
 ## 🤝 Contributing
 
-We welcome contributions! Feel free to:
+We welcome all contributions! Here's how to get started:
 
 - Fork the repository
+- Create a new branch
 - Submit a pull request
-- Open an issue for bugs or suggestions
+- Open issues for bugs or ideas
 
-GitHub: [https://github.com/tezxjs](https://github.com/tezxjs)
+👉 GitHub: [https://github.com/tezxjs](https://github.com/tezxjs)
 
 ---
 
-## 💖 Sponsor TezX
+## 💖 Support TezX
+
+TezX is open-source and developed with love. If you find it helpful:
 
-TezX is an open-source project built with love and passion. If you find it helpful, consider supporting its development:
+- 🌟 Star the project on [GitHub](https://github.com/tezxjs/TezX)
+- 💸 [Sponsor on GitHub](https://github.com/sponsors/srakib17)
 
-- 🌟 [Star on GitHub](https://github.com/tezxjs/TezX)
 <!-- - ☕ [Buy Me a Coffee](https://www.buymeacoffee.com/srakib17) -->
-- 💸 Become a sponsor on [GitHub Sponsors](https://github.com/sponsors/srakib17)
 
-Your support helps us maintain and improve TezX for developers around the world. Thank you!
+Your support helps improve and maintain TezX for everyone.
 
-## Our Sponsor
+---
+
+## 🙌 Sponsor
 
 [![papernxt](https://papernxt.com/favicon.ico)](https://papernxt.com)
 
@@ -258,6 +293,4 @@ Your support helps us maintain and improve TezX for developers around the world.
 
 ## 📜 License
 
-TezX is open-source software licensed under the [MIT License](./LICENSE).
-
----
+This project is licensed under the [MIT License](./LICENSE).

package/bun/getConnInfo.d.ts

@@ -0,0 +1,21 @@
+import { Middleware } from "../types/index.js";
+/**
+ * Middleware to extract and inject connection information into the request context.
+ *
+ * This middleware reads the socket's remote address information (like IP, port, and family)
+ * from the request object and attaches it to `ctx.req.remoteAddress`.
+ *
+ * @returns {Middleware<any>} The middleware function that sets `ctx.req.remoteAddress`.
+ *
+ * @example
+ * import { getConnInfo } from "tezx/bun";
+ *
+ * app.use(getConnInfo());
+ *
+ * // Access later in route handler:
+ * router.get("/", (ctx) => {
+ *   const ip = ctx.req.remoteAddress?.address;
+ *   return new Response(`Your IP: ${ip}`);
+ * });
+ */
+export declare function getConnInfo<T extends Record<string, any> = {}, Path extends string = any>(): Middleware<T, Path>;

package/bun/getConnInfo.js

@@ -0,0 +1,9 @@
+export function getConnInfo() {
+    return (ctx, next) => {
+        let server = ctx.args?.[0];
+        if (server && server.requestIP) {
+            ctx.req.remoteAddress = server.requestIP(ctx.rawRequest);
+        }
+        return next();
+    };
+}

package/bun/index.d.ts

@@ -1,9 +1,15 @@
 import { loadEnv } from "../node/env.js";
-import { bunAdapter } from "./adapter.js";
-export * from "../node/env.js";
-export * from "./adapter.js";
+import { serveStatic } from "../node/serveStatic.js";
+import { getConnInfo } from "./getConnInfo.js";
+import upgradeWebSocket, { wsHandlers } from "./ws.js";
+export type { ServeStatic, StaticFileArray, StaticServeOption, WebSocketCallback, WebSocketEvent, WebSocketOptions, } from "../types/index.js";
+export type { wsHandlersOptions } from "./ws.js";
+export { getConnInfo, loadEnv, serveStatic, upgradeWebSocket, wsHandlers };
 declare const _default: {
-    bunAdapter: typeof bunAdapter;
+    getConnInfo: typeof getConnInfo;
+    wsHandlers: (options?: import("./ws.js").wsHandlersOptions) => Bun.WebSocketHandler;
     loadEnv: typeof loadEnv;
+    upgradeWebSocket: typeof upgradeWebSocket;
+    serveStatic: typeof serveStatic;
 };
 export default _default;

package/bun/index.js

@@ -1,8 +1,12 @@
 import { loadEnv } from "../node/env.js";
-import { bunAdapter } from "./adapter.js";
-export * from "../node/env.js";
-export * from "./adapter.js";
+import { serveStatic } from "../node/serveStatic.js";
+import { getConnInfo } from "./getConnInfo.js";
+import upgradeWebSocket, { wsHandlers } from "./ws.js";
+export { getConnInfo, loadEnv, serveStatic, upgradeWebSocket, wsHandlers };
 export default {
-    bunAdapter,
+    getConnInfo,
+    wsHandlers,
     loadEnv,
+    upgradeWebSocket,
+    serveStatic,
 };

package/bun/ws.d.ts

@@ -0,0 +1,48 @@
+import { Middleware, WebSocketCallback, WebSocketOptions } from "../types/index.js";
+/**
+ * Creates a middleware that upgrades an HTTP request to a WebSocket connection
+ * if the request meets the WebSocket upgrade protocol.
+ *
+ * Supports Bun natively. Node.js requires `req` + `socket` to be passed correctly.
+ */
+export declare function upgradeWebSocket<T extends Record<string, any> & {
+    wsProtocol: "wss" | "ws";
+}, Path extends string = any>(callback: WebSocketCallback, options?: WebSocketOptions): Middleware<T, Path>;
+export type wsHandlersOptions = {
+    /**
+     * Maximum payload size in bytes. Default: 16 MB.
+     */
+    maxPayloadLength?: number;
+    /**
+     * Maximum backpressure limit in bytes. Default: 16 MB.
+     */
+    backpressureLimit?: number;
+    /**
+     * Close connection when backpressure limit reached. Default: false.
+     */
+    closeOnBackpressureLimit?: boolean;
+    /**
+     * Idle timeout in seconds. Default: 120 (2 minutes).
+     */
+    idleTimeout?: number;
+    /**
+     * Whether ws.publish() sends message to itself if subscribed. Default: false.
+     */
+    publishToSelf?: boolean;
+    /**
+     * Whether the server sends/responds to pings automatically. Default: true.
+     */
+    sendPings?: boolean;
+    /**
+     * Compression settings for per-message deflate.
+     */
+    perMessageDeflate?: boolean | {
+        compress?: Bun.WebSocketCompressor | boolean;
+        decompress?: Bun.WebSocketCompressor | boolean;
+    };
+};
+/**
+ * Returns a Bun-compatible WebSocketHandler with optional custom options.
+ */
+export declare const wsHandlers: (options?: wsHandlersOptions) => Bun.WebSocketHandler;
+export default upgradeWebSocket;

package/bun/ws.js

@@ -0,0 +1,58 @@
+import { TezXError } from "../core/error.js";
+export function upgradeWebSocket(callback, options = {}) {
+    const { onUpgradeError = (error, ctx) => {
+        ctx.setStatus = 401;
+        return ctx.text(error.message);
+    }, } = options;
+    return async (ctx, next) => {
+        const upgrade = ctx.req.header("upgrade")?.toLowerCase();
+        const connection = ctx.req.header("connection")?.toLowerCase();
+        const key = ctx.req.header("sec-websocket-key");
+        if (upgrade !== "websocket" || !connection?.includes("upgrade") || !key) {
+            if (next) {
+                ctx.body = { error: "401 Bad Request: Invalid WebSocket headers" };
+                return next();
+            }
+            ctx.setStatus = 401;
+            return onUpgradeError(new TezXError("401 Bad Request: Invalid WebSocket headers", 401), ctx);
+        }
+        ctx.wsProtocol = ctx.url?.startsWith("https") ? "wss" : "ws";
+        if (!callback) {
+            throw new TezXError("WebSocket callback is missing. Please provide a valid callback function to handle the WebSocket events.");
+        }
+        let args = ctx.args[0];
+        if (!args?.upgrade) {
+            return onUpgradeError(new TezXError("Bun server instance missing for WebSocket"), ctx);
+        }
+        const success = args.upgrade(ctx.rawRequest, {
+            data: callback(ctx),
+        });
+        if (success)
+            return undefined;
+        return next();
+    };
+}
+export const wsHandlers = (options) => {
+    return {
+        open(ws) {
+            return ws.data?.open?.(ws);
+        },
+        message(ws, msg) {
+            return ws.data?.message?.(ws, msg);
+        },
+        close(ws, code, reason) {
+            return ws.data?.close?.(ws, { code, reason });
+        },
+        ping(ws, data) {
+            return ws.data?.ping?.(ws, data);
+        },
+        pong(ws, data) {
+            return ws.data?.pong?.(ws, data);
+        },
+        drain(ws) {
+            return ws.data?.drain?.(ws);
+        },
+        ...options,
+    };
+};
+export default upgradeWebSocket;

package/cjs/bun/getConnInfo.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnInfo = getConnInfo;
+function getConnInfo() {
+    return (ctx, next) => {
+        let server = ctx.args?.[0];
+        if (server && server.requestIP) {
+            ctx.req.remoteAddress = server.requestIP(ctx.rawRequest);
+        }
+        return next();
+    };
+}

package/cjs/bun/index.js

@@ -10,15 +10,43 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.wsHandlers = exports.upgradeWebSocket = exports.serveStatic = exports.loadEnv = exports.getConnInfo = void 0;
 const env_js_1 = require("../node/env.js");
-const adapter_js_1 = require("./adapter.js");
-__exportStar(require("../node/env.js"), exports);
-__exportStar(require("./adapter.js"), exports);
+Object.defineProperty(exports, "loadEnv", { enumerable: true, get: function () { return env_js_1.loadEnv; } });
+const serveStatic_js_1 = require("../node/serveStatic.js");
+Object.defineProperty(exports, "serveStatic", { enumerable: true, get: function () { return serveStatic_js_1.serveStatic; } });
+const getConnInfo_js_1 = require("./getConnInfo.js");
+Object.defineProperty(exports, "getConnInfo", { enumerable: true, get: function () { return getConnInfo_js_1.getConnInfo; } });
+const ws_js_1 = __importStar(require("./ws.js"));
+exports.upgradeWebSocket = ws_js_1.default;
+Object.defineProperty(exports, "wsHandlers", { enumerable: true, get: function () { return ws_js_1.wsHandlers; } });
 exports.default = {
-    bunAdapter: adapter_js_1.bunAdapter,
+    getConnInfo: getConnInfo_js_1.getConnInfo,
+    wsHandlers: ws_js_1.wsHandlers,
     loadEnv: env_js_1.loadEnv,
+    upgradeWebSocket: ws_js_1.default,
+    serveStatic: serveStatic_js_1.serveStatic,
 };

package/cjs/bun/ws.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wsHandlers = void 0;
+exports.upgradeWebSocket = upgradeWebSocket;
+const error_js_1 = require("../core/error.js");
+function upgradeWebSocket(callback, options = {}) {
+    const { onUpgradeError = (error, ctx) => {
+        ctx.setStatus = 401;
+        return ctx.text(error.message);
+    }, } = options;
+    return async (ctx, next) => {
+        const upgrade = ctx.req.header("upgrade")?.toLowerCase();
+        const connection = ctx.req.header("connection")?.toLowerCase();
+        const key = ctx.req.header("sec-websocket-key");
+        if (upgrade !== "websocket" || !connection?.includes("upgrade") || !key) {
+            if (next) {
+                ctx.body = { error: "401 Bad Request: Invalid WebSocket headers" };
+                return next();
+            }
+            ctx.setStatus = 401;
+            return onUpgradeError(new error_js_1.TezXError("401 Bad Request: Invalid WebSocket headers", 401), ctx);
+        }
+        ctx.wsProtocol = ctx.url?.startsWith("https") ? "wss" : "ws";
+        if (!callback) {
+            throw new error_js_1.TezXError("WebSocket callback is missing. Please provide a valid callback function to handle the WebSocket events.");
+        }
+        let args = ctx.args[0];
+        if (!args?.upgrade) {
+            return onUpgradeError(new error_js_1.TezXError("Bun server instance missing for WebSocket"), ctx);
+        }
+        const success = args.upgrade(ctx.rawRequest, {
+            data: callback(ctx),
+        });
+        if (success)
+            return undefined;
+        return next();
+    };
+}
+const wsHandlers = (options) => {
+    return {
+        open(ws) {
+            return ws.data?.open?.(ws);
+        },
+        message(ws, msg) {
+            return ws.data?.message?.(ws, msg);
+        },
+        close(ws, code, reason) {
+            return ws.data?.close?.(ws, { code, reason });
+        },
+        ping(ws, data) {
+            return ws.data?.ping?.(ws, data);
+        },
+        pong(ws, data) {
+            return ws.data?.pong?.(ws, data);
+        },
+        drain(ws) {
+            return ws.data?.drain?.(ws);
+        },
+        ...options,
+    };
+};
+exports.wsHandlers = wsHandlers;
+exports.default = upgradeWebSocket;