tezx 1.0.56 → 1.0.58

package/adapter/bun.d.ts

@@ -1,4 +1,98 @@
 import { TezX } from "../core/server.js";
-export declare function bunAdapter<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>, options?: {
+    /**
+     * If set, the HTTP server will listen on a unix socket instead of a port.
+     * (Cannot be used with hostname+port)
+     */
+    unix: string;
+} | {
+    /**
+     * What is the maximum size of a request body? (in bytes)
+     * @default 1024 * 1024 * 128 // 128MB
+     */
+    maxRequestBodySize?: number;
+    /**
+     * Render contextual errors? This enables bun's error page
+     * @default process.env.NODE_ENV !== 'production'
+     */
+    development?: boolean | {
+        /**
+         * Enable Hot Module Replacement for routes (including React Fast Refresh, if React is in use)
+         *
+         * @default true if process.env.NODE_ENV !== 'production'
+         *
+         */
+        hmr?: boolean;
+    };
+    error?: (s: Bun.Serve, error: Error) => Response | Promise<Response> | void | Promise<void>;
+    /**
+     * Uniquely identify a server instance with an ID
+     *
+     * ### When bun is started with the `--hot` flag
+     *
+     * This string will be used to hot reload the server without interrupting
+     * pending requests or websockets. If not provided, a value will be
+     * generated. To disable hot reloading, set this value to `null`.
+     *
+     * ### When bun is not started with the `--hot` flag
+     *
+     * This string will currently do nothing. But in the future it could be useful for logs or metrics.
+     */
+    id?: string | null;
+    /**
+     * What port should the server listen on?
+     * @default process.env.PORT || "3000"
+     */
+    port?: string | number;
+    /**
+     * Whether the `SO_REUSEPORT` flag should be set.
+     *
+     * This allows multiple processes to bind to the same port, which is useful for load balancing.
+     *
+     * @default false
+     */
+    reusePort?: boolean;
+    /**
+     * Whether the `IPV6_V6ONLY` flag should be set.
+     * @default false
+     */
+    ipv6Only?: boolean;
+    /**
+     * What hostname should the server listen on?
+     *
+     * @default
+     * ```js
+     * "0.0.0.0" // listen on all interfaces
+     * ```
+     * @example
+     *  ```js
+     * "127.0.0.1" // Only listen locally
+     * ```
+     * @example
+     * ```js
+     * "remix.run" // Only listen on remix.run
+     * ````
+     *
+     * note: hostname should not include a {@link port}
+     */
+    hostname?: string;
+    /**
+     * If set, the HTTP server will listen on a unix socket instead of a port.
+     * (Cannot be used with hostname+port)
+     */
+    unix?: never;
+    /**
+     * Sets the the number of seconds to wait before timing out a connection
+     * due to inactivity.
+     *
+     * Default is `10` seconds.
+     */
+    idleTimeout?: number;
+    tls?: Bun.TLSOptions | Bun.TLSOptions[];
+}): {
+    listen: {
+        (callback?: (message: string) => void): any;
+        (port?: number): any;
+        (port?: number, callback?: (message: string) => void): any;
+    };
 };

package/adapter/bun.js

@@ -1,72 +1,90 @@
 import { GlobalConfig } from "../core/config.js";
 import { Context } from "../core/context.js";
-export function bunAdapter(TezX) {
-    function listen(port, callback) {
+export function bunAdapter(TezX, options = {}) {
+    function listen(...arg) {
+        let port = typeof arg?.[0] === "number" ? arg?.[0] : undefined;
+        let callback = typeof arg[0] == "function" ? arg[0] : arg?.[1];
         const serve = typeof Bun !== "undefined" ? Bun.serve : null;
         try {
             if (!serve) {
                 throw new Error("Bun is not find");
             }
             GlobalConfig.adapter = "bun";
-            const server = serve({
-                port: port,
-                async fetch(req) {
-                    let options = {
-                        connInfo: {
-                            remoteAddr: server.requestIP(req),
-                            localAddr: server.address,
+            let server;
+            server =
+                options?.unix || typeof options?.unix == "string"
+                    ? serve({
+                        unix: options?.unix,
+                        fetch: () => {
+                            return new Response("4004");
+                        },
+                    })
+                    : serve({
+                        error: (error) => {
+                            return (options?.error)(server, error);
+                        },
+                        development: options?.development,
+                        hostname: options?.hostname,
+                        id: options?.id,
+                        idleTimeout: options?.idleTimeout,
+                        ipv6Only: options?.ipv6Only,
+                        maxRequestBodySize: options?.maxRequestBodySize,
+                        reusePort: options?.reusePort,
+                        tls: options?.tls,
+                        port: options?.port || port,
+                        async fetch(req) {
+                            let options = {
+                                connInfo: {
+                                    remoteAddr: server.requestIP(req),
+                                    localAddr: server.address,
+                                },
+                            };
+                            const response = await TezX.serve(req, options);
+                            if (typeof response?.websocket == "function" &&
+                                response.ctx instanceof Context &&
+                                response.ctx.wsProtocol) {
+                                let websocket = response?.websocket(response?.ctx);
+                                const upgradeSuccess = server.upgrade(req, {
+                                    data: { ...websocket },
+                                });
+                                if (upgradeSuccess)
+                                    return undefined;
+                            }
+                            if (response instanceof Response) {
+                                return response;
+                            }
+                            return new Response(response.body ?? null, {
+                                status: response.status ?? 200,
+                                statusText: response.statusText || "",
+                                headers: new Headers(response.headers ?? {}),
+                            });
+                        },
+                        websocket: {
+                            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);
+                            },
                         },
-                    };
-                    const response = await TezX.serve(req, options);
-                    if (typeof response?.websocket == "function" &&
-                        response.ctx instanceof Context &&
-                        response.ctx.wsProtocol) {
-                        let websocket = response?.websocket(response?.ctx);
-                        const upgradeSuccess = server.upgrade(req, {
-                            data: { ...websocket },
-                        });
-                        if (upgradeSuccess)
-                            return undefined;
-                    }
-                    if (response instanceof Response) {
-                        return response;
-                    }
-                    return new Response(response.body ?? null, {
-                        status: response.status ?? 200,
-                        statusText: response.statusText || "",
-                        headers: new Headers(response.headers ?? {}),
                     });
-                },
-                websocket: {
-                    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);
-                    },
-                },
-            });
             GlobalConfig.server = 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);
-            }
+            const message = `\x1b[1m Bun TezX Server running at ${server.url}\x1b[0m`;
+            GlobalConfig.debugging.success(message);
+            if (typeof callback == "function")
+                callback();
             return server;
         }
         catch (err) {

package/adapter/deno.d.ts

@@ -1,4 +1,8 @@
 import { TezX } from "../core/server.js";
-export declare function denoAdapter<T extends Record<string, any> = {}>(TezX: TezX<T>): {
-    listen: (port: number, callback?: (message: string) => void) => any;
+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;
+        (port?: number): any;
+        (port?: number, callback?: (message: string) => void): any;
+    };
 };

package/adapter/deno.js

@@ -1,11 +1,13 @@
 import { GlobalConfig } from "../core/config.js";
-export function denoAdapter(TezX) {
-    function listen(port, callback) {
+export function denoAdapter(TezX, options = {}) {
+    function listen(...arg) {
+        let port = typeof arg?.[0] === "number" ? arg?.[0] : undefined;
+        let callback = typeof arg[0] == "function" ? arg[0] : arg?.[1];
         const isDeno = typeof Deno !== "undefined";
         try {
             async function handleRequest(req, connInfo) {
                 let remoteAddr = connInfo.remoteAddr;
-                let localAddr = { ...server.addr };
+                let localAddr = { ...server?.addr };
                 let address = {
                     remoteAddr: {
                         port: remoteAddr?.port,
@@ -33,20 +35,23 @@ export function denoAdapter(TezX) {
                     headers: new Headers(response.headers ?? {}),
                 });
             }
-            const server = isDeno ? Deno.serve({ port }, handleRequest) : null;
+            const server = isDeno
+                ? options.transport === "unix"
+                    ? Deno.serve(options, handleRequest)
+                    : Deno.serve({ ...options, port }, handleRequest)
+                : null;
             if (!server) {
                 throw new Error("Deno is not find");
             }
             GlobalConfig.adapter = "deno";
             GlobalConfig.server = server;
-            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);
-            }
+            const protocol = `\x1b[1;34m${options?.cert && options?.key ? "https" : "http"}\x1b[0m`;
+            const message = options?.transport !== "unix"
+                ? `\x1b[1m🚀 Deno TezX Server running at ${protocol}://${(server?.addr).hostname}:${server?.addr?.port}/\x1b[0m`
+                : `\x1b[1m🚀 Deno TezX Server running at ${server?.addr?.transport}://${server?.addr?.path}\x1b[0m`;
+            GlobalConfig.debugging.success(message);
+            if (typeof callback === "function")
+                callback();
             return server;
         }
         catch (err) {

package/adapter/node.d.ts

@@ -1,4 +1,19 @@
+import type { ServerOptions } from "node:http";
+import type { TlsOptions } from "node:tls";
 import { TezX } from "../core/server.js";
-export declare function nodeAdapter<T extends Record<string, any> = {}>(TezX: TezX<T>): {
-    listen: (port: number, callback?: (message: string) => void) => void;
+type UnixSocketOptions = ServerOptions & {
+    unix?: string;
+    enableSSL?: false;
 };
+type SSLOptions = ServerOptions & TlsOptions & {
+    enableSSL: true;
+};
+type TezXServerOptions = UnixSocketOptions | SSLOptions;
+export declare function nodeAdapter<T extends Record<string, any> = {}>(TezX: TezX<T>, options?: TezXServerOptions): {
+    listen: {
+        (callback?: (message: string) => void): any;
+        (port?: number): any;
+        (port?: number, callback?: (message: string) => void): any;
+    };
+};
+export {};

package/adapter/node.js

@@ -1,11 +1,13 @@
+import { Buffer } from "node:buffer";
 import { GlobalConfig } from "../core/config.js";
 import { Context } from "../core/context.js";
-export function nodeAdapter(TezX) {
-    function listen(port, callback) {
-        import("http")
+export function nodeAdapter(TezX, options = {}) {
+    function listen(...arg) {
+        let ssl = options?.enableSSL;
+        import(ssl ? "node:https" : 'node:http')
             .then((r) => {
             GlobalConfig.adapter = "node";
-            let server = r.createServer(async (req, res) => {
+            let server = r.createServer(options, async (req, res) => {
                 let address = {};
                 if (req.socket) {
                     address = {
@@ -42,21 +44,28 @@ export function nodeAdapter(TezX) {
                     res.statusMessage = statusText;
                 }
                 res.writeHead(response.status, headers);
-                const { Readable } = await import("stream");
+                const { Readable } = await import("node:stream");
                 if (response.body instanceof Readable) {
-                    response.body.pipe(res);
+                    return response.body.pipe(res);
                 }
                 else {
-                    const body = await response.arrayBuffer();
-                    if (body.byteLength > 0) {
-                        return res.end(Buffer.from(body));
+                    const buffer = await response.arrayBuffer();
+                    if (buffer.byteLength > 0) {
+                        return res.end(Buffer.from(buffer));
+                    }
+                    else {
+                        return res.end();
                     }
-                    res.end();
                 }
             });
-            server.listen(port, () => {
-                const protocol = "\x1b[1;34mhttp\x1b[0m";
-                const message = `\x1b[1m NodeJS TezX Server running at ${protocol}://localhost:${port}/\x1b[0m`;
+            const port = typeof arg[0] === "number" ? arg[0] : undefined;
+            const callback = typeof arg[0] === "function" ? arg[0] : arg[1];
+            server.listen(options?.unix || port || 0, () => {
+                const protocol = ssl ? "\x1b[1;35mhttps\x1b[0m" : "\x1b[1;34mhttp\x1b[0m";
+                const address = server.address();
+                const message = typeof address === "string"
+                    ? `\x1b[1mNodeJS TezX Server running at unix://${address}\x1b[0m`
+                    : `\x1b[1mNodeJS TezX Server running at ${protocol}://localhost:${address?.port}/\x1b[0m`;
                 GlobalConfig.server = server;
                 if (typeof callback == "function") {
                     callback(message);

package/cjs/adapter/bun.js

@@ -3,73 +3,91 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.bunAdapter = bunAdapter;
 const config_js_1 = require("../core/config.js");
 const context_js_1 = require("../core/context.js");
-function bunAdapter(TezX) {
-    function listen(port, callback) {
+function bunAdapter(TezX, options = {}) {
+    function listen(...arg) {
+        let port = typeof arg?.[0] === "number" ? arg?.[0] : undefined;
+        let callback = typeof arg[0] == "function" ? arg[0] : arg?.[1];
         const serve = typeof Bun !== "undefined" ? Bun.serve : null;
         try {
             if (!serve) {
                 throw new Error("Bun is not find");
             }
             config_js_1.GlobalConfig.adapter = "bun";
-            const server = serve({
-                port: port,
-                async fetch(req) {
-                    let options = {
-                        connInfo: {
-                            remoteAddr: server.requestIP(req),
-                            localAddr: server.address,
+            let server;
+            server =
+                options?.unix || typeof options?.unix == "string"
+                    ? serve({
+                        unix: options?.unix,
+                        fetch: () => {
+                            return new Response("4004");
+                        },
+                    })
+                    : serve({
+                        error: (error) => {
+                            return (options?.error)(server, error);
+                        },
+                        development: options?.development,
+                        hostname: options?.hostname,
+                        id: options?.id,
+                        idleTimeout: options?.idleTimeout,
+                        ipv6Only: options?.ipv6Only,
+                        maxRequestBodySize: options?.maxRequestBodySize,
+                        reusePort: options?.reusePort,
+                        tls: options?.tls,
+                        port: options?.port || port,
+                        async fetch(req) {
+                            let options = {
+                                connInfo: {
+                                    remoteAddr: server.requestIP(req),
+                                    localAddr: server.address,
+                                },
+                            };
+                            const response = await TezX.serve(req, options);
+                            if (typeof response?.websocket == "function" &&
+                                response.ctx instanceof context_js_1.Context &&
+                                response.ctx.wsProtocol) {
+                                let websocket = response?.websocket(response?.ctx);
+                                const upgradeSuccess = server.upgrade(req, {
+                                    data: { ...websocket },
+                                });
+                                if (upgradeSuccess)
+                                    return undefined;
+                            }
+                            if (response instanceof Response) {
+                                return response;
+                            }
+                            return new Response(response.body ?? null, {
+                                status: response.status ?? 200,
+                                statusText: response.statusText || "",
+                                headers: new Headers(response.headers ?? {}),
+                            });
+                        },
+                        websocket: {
+                            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);
+                            },
                         },
-                    };
-                    const response = await TezX.serve(req, options);
-                    if (typeof response?.websocket == "function" &&
-                        response.ctx instanceof context_js_1.Context &&
-                        response.ctx.wsProtocol) {
-                        let websocket = response?.websocket(response?.ctx);
-                        const upgradeSuccess = server.upgrade(req, {
-                            data: { ...websocket },
-                        });
-                        if (upgradeSuccess)
-                            return undefined;
-                    }
-                    if (response instanceof Response) {
-                        return response;
-                    }
-                    return new Response(response.body ?? null, {
-                        status: response.status ?? 200,
-                        statusText: response.statusText || "",
-                        headers: new Headers(response.headers ?? {}),
                     });
-                },
-                websocket: {
-                    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);
-                    },
-                },
-            });
             config_js_1.GlobalConfig.server = 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 {
-                config_js_1.GlobalConfig.debugging.success(message);
-            }
+            const message = `\x1b[1m Bun TezX Server running at ${server.url}\x1b[0m`;
+            config_js_1.GlobalConfig.debugging.success(message);
+            if (typeof callback == "function")
+                callback();
             return server;
         }
         catch (err) {

package/cjs/adapter/deno.js

@@ -2,13 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.denoAdapter = denoAdapter;
 const config_js_1 = require("../core/config.js");
-function denoAdapter(TezX) {
-    function listen(port, callback) {
+function denoAdapter(TezX, options = {}) {
+    function listen(...arg) {
+        let port = typeof arg?.[0] === "number" ? arg?.[0] : undefined;
+        let callback = typeof arg[0] == "function" ? arg[0] : arg?.[1];
         const isDeno = typeof Deno !== "undefined";
         try {
             async function handleRequest(req, connInfo) {
                 let remoteAddr = connInfo.remoteAddr;
-                let localAddr = { ...server.addr };
+                let localAddr = { ...server?.addr };
                 let address = {
                     remoteAddr: {
                         port: remoteAddr?.port,
@@ -36,20 +38,23 @@ function denoAdapter(TezX) {
                     headers: new Headers(response.headers ?? {}),
                 });
             }
-            const server = isDeno ? Deno.serve({ port }, handleRequest) : null;
+            const server = isDeno
+                ? options.transport === "unix"
+                    ? Deno.serve(options, handleRequest)
+                    : Deno.serve({ ...options, port }, handleRequest)
+                : null;
             if (!server) {
                 throw new Error("Deno is not find");
             }
             config_js_1.GlobalConfig.adapter = "deno";
             config_js_1.GlobalConfig.server = server;
-            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 {
-                config_js_1.GlobalConfig.debugging.success(message);
-            }
+            const protocol = `\x1b[1;34m${options?.cert && options?.key ? "https" : "http"}\x1b[0m`;
+            const message = options?.transport !== "unix"
+                ? `\x1b[1m🚀 Deno TezX Server running at ${protocol}://${(server?.addr).hostname}:${server?.addr?.port}/\x1b[0m`
+                : `\x1b[1m🚀 Deno TezX Server running at ${server?.addr?.transport}://${server?.addr?.path}\x1b[0m`;
+            config_js_1.GlobalConfig.debugging.success(message);
+            if (typeof callback === "function")
+                callback();
             return server;
         }
         catch (err) {

package/cjs/adapter/node.js

@@ -1,13 +1,15 @@
 "use strict";
 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");
-function nodeAdapter(TezX) {
-    function listen(port, callback) {
-        Promise.resolve().then(() => require("http")).then((r) => {
+function nodeAdapter(TezX, options = {}) {
+    function listen(...arg) {
+        let ssl = options?.enableSSL;
+        Promise.resolve(`${ssl ? "node:https" : 'node:http'}`).then(s => require(s)).then((r) => {
             config_js_1.GlobalConfig.adapter = "node";
-            let server = r.createServer(async (req, res) => {
+            let server = r.createServer(options, async (req, res) => {
                 let address = {};
                 if (req.socket) {
                     address = {
@@ -44,21 +46,28 @@ function nodeAdapter(TezX) {
                     res.statusMessage = statusText;
                 }
                 res.writeHead(response.status, headers);
-                const { Readable } = await Promise.resolve().then(() => require("stream"));
+                const { Readable } = await Promise.resolve().then(() => require("node:stream"));
                 if (response.body instanceof Readable) {
-                    response.body.pipe(res);
+                    return response.body.pipe(res);
                 }
                 else {
-                    const body = await response.arrayBuffer();
-                    if (body.byteLength > 0) {
-                        return res.end(Buffer.from(body));
+                    const buffer = await response.arrayBuffer();
+                    if (buffer.byteLength > 0) {
+                        return res.end(node_buffer_1.Buffer.from(buffer));
+                    }
+                    else {
+                        return res.end();
                     }
-                    res.end();
                 }
             });
-            server.listen(port, () => {
-                const protocol = "\x1b[1;34mhttp\x1b[0m";
-                const message = `\x1b[1m NodeJS TezX Server running at ${protocol}://localhost:${port}/\x1b[0m`;
+            const port = typeof arg[0] === "number" ? arg[0] : undefined;
+            const callback = typeof arg[0] === "function" ? arg[0] : arg[1];
+            server.listen(options?.unix || port || 0, () => {
+                const protocol = ssl ? "\x1b[1;35mhttps\x1b[0m" : "\x1b[1;34mhttp\x1b[0m";
+                const address = server.address();
+                const message = typeof address === "string"
+                    ? `\x1b[1mNodeJS TezX Server running at unix://${address}\x1b[0m`
+                    : `\x1b[1mNodeJS TezX Server running at ${protocol}://localhost:${address?.port}/\x1b[0m`;
                 config_js_1.GlobalConfig.server = server;
                 if (typeof callback == "function") {
                     callback(message);

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.56";
+exports.version = "1.0.58";

package/cjs/middleware/detectBot.js

@@ -70,7 +70,6 @@ function createRateLimitDefaultStorage() {
     return {
         get: (key) => store.get(key),
         set: (key, value) => store.set(key, value),
-        delete: (key) => store.delete(key),
         clearExpired: () => {
             const now = Date.now();
             for (const [key, entry] of store.entries()) {

package/cjs/ws/deno.js

@@ -3,15 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DenoTransport = void 0;
 class DenoTransport {
     async upgrade(ctx, event, options) {
-        const { socket, response } = Deno.upgradeWebSocket(ctx.req.rawRequest, {
-            protocols: options.protocols,
+        const { socket, response } = (Deno).upgradeWebSocket(ctx.req.rawRequest, {
+            protocol: options.protocol,
             idleTimeout: options.idleTimeout,
-            headers: {},
         });
-        this.setupHandlers(socket, ctx, event, options);
+        this.setupHandlers(socket, ctx, event);
         return response;
     }
-    setupHandlers(ws, ctx, event, options) {
+    setupHandlers(ws, ctx, event) {
         ws.onopen = () => event.open?.(ws, ctx);
         ws.onmessage = (e) => event.message?.(ws, e.data);
         ws.onclose = (e) => event.close?.(ws, { code: e.code, reason: e.reason });

package/cjs/ws/index.js

@@ -8,7 +8,7 @@ function upgradeWebSocket(callback, options = {}) {
     const { onUpgradeError = (error, ctx) => {
         ctx.setStatus = 401;
         return ctx.text(error.message);
-    }, protocols = [], idleTimeout = 30000, perMessageDeflate, maxPayload = 1048576, } = options;
+    }, protocol, idleTimeout = 30000, perMessageDeflate, maxPayload = 1048576, } = options;
     return async (ctx, next) => {
         const upgrade = ctx.req.headers.get("upgrade")?.toLowerCase();
         const connection = ctx.req.headers.get("connection")?.toLowerCase();
@@ -32,7 +32,7 @@ function upgradeWebSocket(callback, options = {}) {
                 case "deno":
                     return new deno_js_1.DenoTransport().upgrade(ctx, websocketCallback, {
                         idleTimeout,
-                        protocols,
+                        protocol,
                     });
                 case "bun":
                     return callback;

package/core/context.d.ts

@@ -1,7 +1,7 @@
 import { State } from "../utils/state.js";
 import { HeadersParser } from "./header.js";
 import { HTTPMethod, Request } from "./request.js";
-import { ServeOptions } from "./server.js";
+import { TezXServeOptions } from "./server.js";
 export interface CookieOptions {
     expires?: Date;
     path?: string;
@@ -48,7 +48,7 @@ export declare class Context<T extends Record<string, any> = {}> {
      */
     state: State;
     protected readonly resBody?: BodyInit | null;
-    constructor(req: any, options: ServeOptions);
+    constructor(req: any, options: TezXServeOptions);
     /**
      * Appends or set a value to an existing header or creates a new one.
      * @param key - Header name.

package/core/request.d.ts

@@ -1,22 +1,22 @@
 import { UrlRef } from "../utils/url.js";
 import { HeadersParser } from "./header.js";
-import { ServeOptions } from "./server.js";
+import { TezXServeOptions } from "./server.js";
 export type FormDataOptions = {
     maxSize?: number;
     allowedTypes?: string[];
     sanitized?: boolean;
     maxFiles?: number;
 };
-type TransportType = "tcp" | "udp" | "unix" | "pipe";
-export type AddressType = {
+type TransportType = "tcp" | "udp" | "unix" | "pipe" | "unixpacket";
+export type NetAddr = {
     transport?: TransportType;
     family?: "IPv4" | "IPv6" | "Unix";
     address?: string;
     port?: number;
 };
 export type ConnAddress = {
-    remoteAddr: AddressType;
-    localAddr: AddressType;
+    remoteAddr: NetAddr;
+    localAddr: NetAddr;
 };
 export type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "OPTIONS" | "PATCH" | "HEAD" | "ALL" | "TRACE" | "CONNECT" | string;
 export declare class Request {
@@ -56,13 +56,13 @@ export declare class Request {
      * ctx.req.remoteAddress
      * ```
      */
-    remoteAddress: AddressType;
+    remoteAddress: NetAddr;
     constructor({ headers, params, req, options, urlRef, }: {
         req: any;
         params: Record<string, any>;
         headers: HeadersParser;
         urlRef: UrlRef;
-        options: ServeOptions;
+        options: TezXServeOptions;
     });
     get headers(): {
         /**

package/core/server.d.ts

@@ -1,7 +1,7 @@
 import { Context } from "./context.js";
 import { ConnAddress, HTTPMethod } from "./request.js";
 import { Middleware, Router, RouterConfig } from "./router.js";
-export type ServeOptions = {
+export type TezXServeOptions = {
     connInfo: ConnAddress;
 };
 export type TezXConfig = {
@@ -64,7 +64,7 @@ export declare class TezX<T extends Record<string, any> = {}> extends Router<T>
         middlewares: Middleware<T>[];
         params: Record<string, string>;
     } | null;
-    serve(req: Request, options: ServeOptions): Promise<Response | {
+    serve(req: Request, options: TezXServeOptions): Promise<Response | {
         websocket: (props: any) => any;
         ctx: Context;
     }>;

package/index.d.ts

@@ -1,7 +1,7 @@
 export { Router } from "./core/router.js";
 export type { Callback, ctx as Context, Middleware, NextCallback, RouterConfig, StaticServeOption, } from "./core/router.js";
 export type { CookieOptions, ResponseHeaders } from "./core/context.js";
-export type { AddressType, ConnAddress, FormDataOptions, HTTPMethod, } from "./core/request.js";
+export type { NetAddr as AddressType, ConnAddress, FormDataOptions, HTTPMethod, } from "./core/request.js";
 export { TezX } from "./core/server.js";
 export type { TezXConfig } from "./core/server.js";
 export { useParams } from "./utils/params.js";

package/index.js

@@ -1,4 +1,4 @@
 export { Router } from "./core/router.js";
 export { TezX } from "./core/server.js";
 export { useParams } from "./utils/params.js";
-export let version = "1.0.56";
+export let version = "1.0.58";

package/middleware/basicAuth.d.ts

@@ -52,7 +52,6 @@ type DynamicBasicAuthOptions = {
                 count: number;
                 resetTime: number;
             }) => void;
-            delete: (key: string) => void;
             clearExpired: () => void;
         };
         /** 🔁 Max requests allowed within the window */

package/middleware/detectBot.d.ts

@@ -1,5 +1,5 @@
-import { Context, Middleware } from "../index.js";
 import { CallbackReturn } from "../core/router.js";
+import { Context, Middleware } from "../index.js";
 export type DetectBotReason = "User-Agent" | "Blacklisted IP" | "Query Parameter" | "Rate Limiting" | "Custom Detector" | "Multiple Indicators";
 type BotDetectionResult = {
     isBot: boolean;
@@ -64,7 +64,6 @@ type DetectBotOptions = {
             count: number;
             resetTime: number;
         }) => void;
-        delete: (key: string) => void;
         clearExpired: () => void;
     };
     /**
@@ -114,7 +113,6 @@ export declare function createRateLimitDefaultStorage(): {
         count: number;
         resetTime: number;
     }>;
-    delete: (key: string) => boolean;
     clearExpired: () => void;
 };
 export declare function isRateLimit(ctx: Context, key: string, store: any, maxRequests: number, windowMs: number): {

package/middleware/detectBot.js

@@ -64,7 +64,6 @@ export function createRateLimitDefaultStorage() {
     return {
         get: (key) => store.get(key),
         set: (key, value) => store.set(key, value),
-        delete: (key) => store.delete(key),
         clearExpired: () => {
             const now = Date.now();
             for (const [key, entry] of store.entries()) {

package/middleware/rateLimiter.d.ts

@@ -37,7 +37,6 @@ export type RateLimiterOptions = {
             count: number;
             resetTime: number;
         }) => void;
-        delete: (key: string) => void;
         clearExpired: () => void;
     };
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tezx",
-  "version": "1.0.56",
+  "version": "1.0.58",
   "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",

package/ws/deno.d.ts

@@ -1,5 +1,5 @@
 import { Context } from "../index.js";
-import { WebSocketOptions, WebSocketEvent } from "./index.js";
+import { WebSocketEvent, WebSocketOptions } from "./index.js";
 export declare class DenoTransport {
     upgrade(ctx: Context, event: WebSocketEvent, options: WebSocketOptions): Promise<Response>;
     private setupHandlers;

package/ws/deno.js

@@ -1,14 +1,13 @@
 export class DenoTransport {
     async upgrade(ctx, event, options) {
-        const { socket, response } = Deno.upgradeWebSocket(ctx.req.rawRequest, {
-            protocols: options.protocols,
+        const { socket, response } = (Deno).upgradeWebSocket(ctx.req.rawRequest, {
+            protocol: options.protocol,
             idleTimeout: options.idleTimeout,
-            headers: {},
         });
-        this.setupHandlers(socket, ctx, event, options);
+        this.setupHandlers(socket, ctx, event);
         return response;
     }
-    setupHandlers(ws, ctx, event, options) {
+    setupHandlers(ws, ctx, event) {
         ws.onopen = () => event.open?.(ws, ctx);
         ws.onmessage = (e) => event.message?.(ws, e.data);
         ws.onclose = (e) => event.close?.(ws, { code: e.code, reason: e.reason });

package/ws/index.d.ts

@@ -162,7 +162,7 @@ export type WebSocketOptions = {
     /**
      * Supported WebSocket subprotocols. (Deno only)
      */
-    protocols?: string[];
+    protocol?: string;
     /**
      * Time (in seconds) after which the WebSocket connection will be closed if idle. (Deno only)
      */

package/ws/index.js

@@ -5,7 +5,7 @@ export function upgradeWebSocket(callback, options = {}) {
     const { onUpgradeError = (error, ctx) => {
         ctx.setStatus = 401;
         return ctx.text(error.message);
-    }, protocols = [], idleTimeout = 30000, perMessageDeflate, maxPayload = 1048576, } = options;
+    }, protocol, idleTimeout = 30000, perMessageDeflate, maxPayload = 1048576, } = options;
     return async (ctx, next) => {
         const upgrade = ctx.req.headers.get("upgrade")?.toLowerCase();
         const connection = ctx.req.headers.get("connection")?.toLowerCase();
@@ -29,7 +29,7 @@ export function upgradeWebSocket(callback, options = {}) {
                 case "deno":
                     return new DenoTransport().upgrade(ctx, websocketCallback, {
                         idleTimeout,
-                        protocols,
+                        protocol,
                     });
                 case "bun":
                     return callback;