tezx 1.0.57 → 1.0.59

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?: () => void): any;
+        (port?: number): any;
+        (port?: number, callback?: () => 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,28 +44,32 @@ 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);
-                }
-                else {
-                    GlobalConfig.debugging.success(message);
-                }
+                GlobalConfig.debugging.success(message);
+                if (typeof callback == "function")
+                    callback();
                 return server;
             });
         })

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) {