tezx 3.0.9-beta → 3.0.11-beta

package/bun/index.d.ts

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

package/bun/index.js

@@ -1,10 +1,11 @@
 import { loadEnv } from "../node/env.js";
 import { serveStatic } from "../node/serveStatic.js";
 import { getConnInfo } from "./getConnInfo.js";
-import upgradeWebSocket from "./ws.js";
-export { getConnInfo, loadEnv, serveStatic, upgradeWebSocket };
+import upgradeWebSocket, { wsHandlers } from "./ws.js";
+export { getConnInfo, loadEnv, serveStatic, upgradeWebSocket, wsHandlers };
 export default {
     getConnInfo,
+    wsHandlers,
     loadEnv,
     upgradeWebSocket,
     serveStatic,

package/bun/ws.d.ts

@@ -8,4 +8,41 @@ import { Middleware, WebSocketCallback, WebSocketOptions } from "../types/index.
 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

@@ -31,4 +31,27 @@ export function upgradeWebSocket(callback, options = {}) {
         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/index.js

@@ -1,19 +1,51 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.upgradeWebSocket = exports.serveStatic = exports.loadEnv = exports.getConnInfo = void 0;
+exports.wsHandlers = exports.upgradeWebSocket = exports.serveStatic = exports.loadEnv = exports.getConnInfo = void 0;
 const env_js_1 = require("../node/env.js");
 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 = __importDefault(require("./ws.js"));
+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 = {
     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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.wsHandlers = void 0;
 exports.upgradeWebSocket = upgradeWebSocket;
 function upgradeWebSocket(callback, options = {}) {
     const { onUpgradeError = (error, ctx) => {
@@ -34,4 +35,28 @@ function upgradeWebSocket(callback, options = {}) {
         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;

package/cjs/core/context.js

@@ -8,24 +8,24 @@ const response_js_1 = require("../utils/response.js");
 const request_js_1 = require("./request.js");
 class Context {
     #status = 200;
-    #headers = { connection: "keep-alive" };
+    #headers;
     #req = null;
     #params = {};
     rawRequest;
     #args;
     #body;
+    url;
+    res;
     env = {};
     pathname;
     method;
-    constructor(req, options) {
-        this.#args = options?.args;
+    constructor(req, pathname, method, env, args) {
+        this.#args = args;
         this.rawRequest = req;
-        this.pathname = options?.pathname;
-        this.env = options?.env || {};
-        this.method = options?.method;
-    }
-    get url() {
-        return this.req.url;
+        this.url = req.url;
+        this.pathname = pathname;
+        this.env = env ?? {};
+        this.method = method;
     }
     get getStatus() {
         return this.#status;
@@ -33,58 +33,28 @@ class Context {
     set setStatus(code) {
         this.#status = code;
     }
-    header(header) {
-        if (header) {
-            return this.#headers[header?.toLowerCase()];
-        }
-        return this.#headers;
-    }
-    set clearHeader(header) {
-        this.#headers = (header || {});
+    get headers() {
+        return this.res?.headers ?? (this.#headers ??= new Headers());
     }
     setHeader(key, value, options) {
-        let _key = key.toLowerCase();
-        let append = options?.append || _key == 'set-cookie';
-        if (!this.res) {
-            if (append && this.#headers[_key]) {
-                this.#headers[_key] += `, ${value}`;
-            }
-            else {
-                this.#headers[_key] = value;
-            }
-        }
-        else {
-            const resHeaders = this.res.headers;
-            if (append) {
-                resHeaders.append(_key, value);
-            }
-            else {
-                resHeaders.set(_key, value);
-            }
-        }
-        return this;
-    }
-    deleteHeader(key) {
+        if (!value)
+            return this;
         const _key = key.toLowerCase();
-        if (!this.res) {
-            delete this.#headers[_key];
+        const append = options?.append || _key === "set-cookie";
+        const target = this.res?.headers ?? (this.#headers ??= new Headers());
+        if (append) {
+            target.append(_key, value);
         }
         else {
-            this.res.headers.delete(_key);
+            target.set(_key, value);
         }
         return this;
     }
-    get params() {
-        return this.#params;
-    }
     set params(params) {
         this.#params = params;
     }
     get req() {
-        if (!this.#req) {
-            this.#req = new request_js_1.TezXRequest(this.rawRequest, this.method, this.pathname, this.#params);
-        }
-        return this.#req;
+        return (this.#req ??= new request_js_1.TezXRequest(this.rawRequest, this.method, this.pathname, this.#params));
     }
     get body() {
         return this.#body;
@@ -96,66 +66,93 @@ class Context {
         this.#status = status;
         return this;
     };
+    #newResponse(body, type, init = {}) {
+        const headers = new Headers(this.#headers);
+        headers.set("Content-Type", type);
+        if (init.headers) {
+            for (const key in init.headers) {
+                const value = init.headers[key];
+                if (!value)
+                    continue;
+                if (key.toLowerCase() === "set-cookie") {
+                    headers.append(key, value);
+                }
+                else {
+                    headers.set(key, value);
+                }
+            }
+        }
+        return new Response(body, {
+            status: init.status ?? this.#status,
+            statusText: init.statusText,
+            headers,
+        });
+    }
     newResponse(body, init = {}) {
-        const headers = { ...this.#headers, ...init.headers };
-        const status = init.status || this.#status;
-        const statusText = init.statusText;
-        return new Response(body, { status, statusText, headers: headers });
+        const headers = new Headers(this.#headers);
+        if (init.headers) {
+            for (const key in init.headers) {
+                const value = init.headers[key];
+                if (!value) {
+                    continue;
+                }
+                if (key.toLowerCase() === "set-cookie") {
+                    headers.append(key, value);
+                }
+                else {
+                    headers.set(key, value);
+                }
+            }
+        }
+        return new Response(body, {
+            status: init.status ?? this.#status,
+            statusText: init.statusText,
+            headers,
+        });
     }
     text(content, init) {
-        return (0, response_js_1.newResponse)(content, "text/plain; charset=utf-8", init, this.#headers, this.#status);
+        return this.#newResponse(content, "text/plain; charset=utf-8", init);
     }
     html(strings, ...args) {
-        let html = strings;
-        if (Array.isArray(strings)) {
-            html = strings.reduce((result, str, i) => {
-                const value = args?.[i] ?? "";
-                return result + str + value;
-            }, "");
-            return (0, response_js_1.newResponse)(html, "text/html; charset=utf-8", {}, this.#headers, this.#status);
-        }
-        else {
-            let init = args?.[0];
-            return (0, response_js_1.newResponse)(html, "text/html; charset=utf-8", init, this.#headers, this.#status);
-        }
+        return this.#newResponse((0, response_js_1.toString)(strings, args), "text/html; charset=utf-8", args?.[0]);
     }
-    xml(xml, init) {
-        return (0, response_js_1.newResponse)(xml, "text/xml; charset=utf-8", init, this.#headers, this.#status);
+    xml(strings, ...args) {
+        return this.#newResponse((0, response_js_1.toString)(strings, args), "text/html; charset=utf-8", args?.[0]);
     }
     json(json, init) {
-        return (0, response_js_1.newResponse)(JSON.stringify(json), "application/json; charset=utf-8", init, this.#headers, this.#status);
+        return this.#newResponse(JSON.stringify(json), "application/json; charset=utf-8", init);
     }
     send(body, init) {
         let { body: _body, type } = (0, response_js_1.determineContentTypeBody)(body);
-        const contentType = init?.headers?.["Content-Type"] ||
-            init?.headers?.["content-type"] ||
+        const contentType = init?.headers?.["Content-Type"] ??
+            init?.headers?.["content-type"] ??
             type;
-        return (0, response_js_1.newResponse)(_body, contentType, {}, this.#headers, this.#status);
+        return this.#newResponse(_body, contentType, init);
     }
     redirect(url, status = 302) {
-        return new Response(null, {
-            status: status,
-            headers: { Location: url },
-        });
+        const headers = new Headers(this.#headers);
+        headers.set("Location", url);
+        return new Response(null, { status, headers });
     }
     async download(filePath, filename) {
         if (!(await (0, file_js_1.fileExists)(filePath)))
             throw Error("File not found");
-        let buf = await (0, file_js_1.getFileBuffer)(filePath);
-        return (0, response_js_1.newResponse)(buf, "application/octet-stream", {
-            status: 200,
-            headers: {
-                "Content-Disposition": `attachment; filename="${filename}"`,
-                "Content-Length": buf.byteLength.toString(),
-            }
-        }, this.#headers, this.#status);
+        const buf = await (0, file_js_1.getFileBuffer)(filePath);
+        const headers = {
+            "Content-Disposition": `attachment; filename="${filename}"`,
+            "Content-Length": buf.byteLength.toString(),
+        };
+        return this.#newResponse(buf, "application/octet-stream", {
+            status: this.#status,
+            headers,
+        });
     }
     async sendFile(filePath, init) {
         if (!(await (0, file_js_1.fileExists)(filePath)))
             throw Error("File not found");
         let size = await (0, file_js_1.fileSize)(filePath);
-        const ext = (0, low_level_js_1.extensionExtract)(filePath) || "";
-        const mimeType = mimeTypes_js_1.mimeTypes[ext] || mimeTypes_js_1.defaultMimeType;
+        const ext = (0, low_level_js_1.extensionExtract)(filePath);
+        const mimeType = mimeTypes_js_1.mimeTypes[ext] ?? mimeTypes_js_1.defaultMimeType;
         let fileStream = await (0, file_js_1.readStream)(filePath);
         let headers = {
             "Content-Type": mimeType,
@@ -163,10 +160,11 @@ class Context {
             ...init?.headers,
         };
         let filename = init?.filename;
-        if (filename)
+        if (filename) {
             headers["Content-Disposition"] = `attachment; filename="${filename}"`;
+        }
         return this.newResponse(fileStream, {
-            status: init?.status || 200,
+            status: init?.status ?? this.#status,
             statusText: init?.statusText,
             headers,
         });

package/cjs/core/error.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TezXError = void 0;
+class TezXError extends Error {
+    statusCode;
+    details;
+    constructor(message, statusCode = 500, details) {
+        super(message);
+        this.statusCode = statusCode;
+        this.details = details;
+        Object.setPrototypeOf(this, new.target.prototype);
+        Error.captureStackTrace(this, this.constructor);
+    }
+    static badRequest(message = "Bad Request", details) {
+        return new TezXError(message, 400, details);
+    }
+    static unauthorized(message = "Unauthorized", details) {
+        return new TezXError(message, 401, details);
+    }
+    static forbidden(message = "Forbidden", details) {
+        return new TezXError(message, 403, details);
+    }
+    static notFound(message = "Resource Not Found", details) {
+        return new TezXError(message, 404, details);
+    }
+    static conflict(message = "Conflict", details) {
+        return new TezXError(message, 409, details);
+    }
+    static internal(message = "Internal Server Error", details) {
+        return new TezXError(message, 500, details);
+    }
+    toJSON() {
+        return {
+            error: true,
+            message: this.message,
+            statusCode: this.statusCode,
+            details: this.details ?? null,
+        };
+    }
+}
+exports.TezXError = TezXError;

package/cjs/core/request.js

@@ -17,22 +17,22 @@ class TezXRequest {
     #headersCache;
     #queryCache;
     constructor(req, method, pathname, params) {
-        this.url = req.url || "";
-        this.params = params || {};
+        this.url = req.url;
+        this.params = params ?? {};
         this.method = method;
         this.#rawRequest = req;
-        this.pathname = pathname || "/";
+        this.pathname = pathname ?? "/";
     }
     header(header) {
         if (header) {
-            return this.#rawRequest.headers.get(header?.toLowerCase());
+            return this.#rawRequest.headers.get(header.toLowerCase());
         }
         if (this.#headersCache)
             return this.#headersCache;
         const obj = {};
-        for (const [key, value] of this.#rawRequest.headers.entries()) {
+        this.#rawRequest.headers.forEach((value, key) => {
             obj[key.toLowerCase()] = value;
-        }
+        });
         this.#headersCache = obj;
         return this.#headersCache;
     }

package/cjs/core/router.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Router = void 0;
-const low_level_js_1 = require("../utils/low-level.js");
 const RadixRouter_js_1 = require("../registry/RadixRouter.js");
+const low_level_js_1 = require("../utils/low-level.js");
 class Router {
     env = {};
     router;
@@ -129,11 +129,9 @@ class Router {
         }
         return this;
     }
-    #addRoute(method, path, handlers, skip = false) {
+    #addRoute(method, path, handlers) {
         let pattern = `/${(0, low_level_js_1.sanitizePathSplitBasePath)(this.basePath, path).join("/")}`;
-        if (!skip) {
-            this.router.addRoute(method, pattern, handlers);
-        }
+        this.router.addRoute(method, pattern, handlers);
         this.route.push({
             method: method,
             pattern: pattern,
@@ -168,7 +166,9 @@ class Router {
     }
     #routeAddTriNode(path, router) {
         this.env = { ...this.env, ...router.env };
-        if (this.router?.name && router.router?.name && this.router?.name !== router.router?.name) {
+        if (this.router?.name &&
+            router.router?.name &&
+            this.router?.name !== router.router?.name) {
             throw new Error(`Router name mismatch: expected "${this.router.name}", got "${router.router.name}"`);
         }
         if (!(router instanceof Router)) {