tezx 2.0.11 → 3.0.0

package/cjs/node/mount-node.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mountTezXOnNode = mountTezXOnNode;
+const node_stream_1 = require("node:stream");
+const config_js_1 = require("../core/config.js");
+const toWebRequest_js_1 = require("./toWebRequest.js");
+function readableStreamToNodeStream(stream) {
+    const reader = stream.getReader();
+    return new node_stream_1.Readable({
+        async read() {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    this.push(null);
+                }
+                else {
+                    this.push(value);
+                }
+            }
+            catch (err) {
+                this.destroy(err);
+            }
+        },
+        destroy(err, callback) {
+            reader.cancel().then(() => callback(err), (cancelErr) => callback(cancelErr));
+        },
+    });
+}
+function mountTezXOnNode(app, server) {
+    server.on("request", async (req, res) => {
+        try {
+            const request = (0, toWebRequest_js_1.toWebRequest)(req, req.method);
+            const response = await app.serve(request, req, res, server);
+            if (res.writableEnded || res.headersSent)
+                return;
+            const { status = 200, statusText = "", headers = {}, body } = response;
+            const nodeHeaders = Object.fromEntries(headers instanceof Headers
+                ? headers.entries()
+                : Object.entries(headers));
+            res.writeHead(status, statusText, nodeHeaders);
+            if (!body) {
+                return res.end();
+            }
+            if (body instanceof node_stream_1.Readable) {
+                return body.pipe(res);
+            }
+            if (typeof body.getReader === "function") {
+                return (node_stream_1.Readable.fromWeb?.(body)?.pipe?.(res) ??
+                    readableStreamToNodeStream(body).pipe(res));
+            }
+            res.end(body);
+        }
+        catch (err) {
+            res.statusCode = 500;
+            config_js_1.GlobalConfig.debugging?.error?.(err?.message || "Unknown error");
+            res.end(err?.message || "Internal Server Error");
+        }
+    });
+}

package/cjs/node/serveStatic.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveStatic = serveStatic;
+exports.getFiles = getFiles;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const low_level_js_1 = require("../utils/low-level.js");
+const error_js_1 = require("../core/error.js");
+function serveStatic(...args) {
+    let route = "";
+    let dir;
+    let options = {};
+    switch (args.length) {
+        case 3:
+            [route, dir, options] = args;
+            break;
+        case 2:
+            if (typeof args[1] === "object") {
+                [dir, options] = args;
+            }
+            else {
+                [route, dir] = args;
+            }
+            break;
+        case 1:
+            [dir] = args;
+            break;
+        default:
+            throw new error_js_1.TezXError(`\x1b[1;31m404 Not Found\x1b[0m \x1b[1;32mInvalid arguments\x1b[0m`);
+    }
+    return {
+        files: getFiles(dir, route, options),
+        options,
+    };
+}
+function getFiles(dir, basePath = "/", option = {}) {
+    const files = [];
+    const entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = (0, node_path_1.join)(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...getFiles(fullPath, `${basePath}/${entry.name}`, option));
+        }
+        else {
+            const ext = (0, low_level_js_1.extensionExtract)(entry.name);
+            if (option?.extensions?.length && !option.extensions.includes(ext)) {
+                continue;
+            }
+            files.push({
+                fileSource: fullPath,
+                route: `/${(0, low_level_js_1.sanitizePathSplitBasePath)(basePath, entry.name).join("/")}`,
+            });
+        }
+    }
+    return files;
+}

package/cjs/node/toWebRequest.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toWebRequest = toWebRequest;
+const node_stream_1 = require("node:stream");
+function toWebRequest(req, method = "GET") {
+    const protocol = req.socket && req.socket.encrypted ? "https:" : "http:";
+    const upperMethod = method.length === 3
+        ? method === "get"
+            ? "GET"
+            : method === "put"
+                ? "PUT"
+                : method.toUpperCase()
+        : method.toUpperCase();
+    let host = req.headers.host || "localhost";
+    const hasBody = upperMethod !== "GET" && upperMethod !== "HEAD";
+    const abortController = new AbortController();
+    req?.once("close", () => abortController.abort());
+    return new Request(protocol + "//" + host + (req.url ?? "/"), {
+        method,
+        headers: req?.headers,
+        body: hasBody ? node_stream_1.Readable.toWeb(req) : undefined,
+        signal: abortController.signal,
+        duplex: hasBody ? "half" : undefined,
+    });
+}

package/cjs/node/ws.js

@@ -0,0 +1,82 @@
+"use strict";
+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 = 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";
+        const server = ctx.args?.[2];
+        if (!server?.on) {
+            ctx.setStatus = 500;
+            return onUpgradeError(new error_js_1.TezXError("Node server instance missing for WebSocket", 426), ctx);
+        }
+        const { WebSocketServer } = await Promise.resolve().then(() => __importStar(require("ws")));
+        const wss = new WebSocketServer({
+            noServer: true,
+            maxPayload: options.maxPayload ?? 1048576,
+            perMessageDeflate: options.perMessageDeflate ?? false,
+        });
+        server.on("upgrade", (request, socket, head) => {
+            wss?.handleUpgrade(request, socket, head, (ws) => {
+                wss?.emit("connection", ws, request);
+                let event = callback(ctx);
+                event.open?.(ws);
+                ws.on("open", () => event.open?.(ws));
+                ws.on("message", (data) => event.message?.(ws, data));
+                ws.on("close", (code, reason) => event.close?.(ws, { code, reason }));
+                ws.on("error", (err) => event.error?.(ws, err));
+                ws.on("ping", (data) => event.ping?.(ws, data));
+                ws.on("pong", (data) => event.pong?.(ws, data));
+            });
+        });
+        return next();
+    };
+}

package/cjs/registry/RadixRouter.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RadixRouter = void 0;
+const error_js_1 = require("../core/error.js");
+const index_js_1 = require("../helper/index.js");
+class RadixRouter {
+    root = { children: {} };
+    name;
+    constructor() {
+        this.name = "RadixRouter";
+    }
+    addRoute(method, path, handlers) {
+        const segments = this.parsePattern(path);
+        let node = this.root;
+        for (let i = 0; i < segments.length; i++) {
+            const { type, value, paramName, isOptional } = segments[i];
+            if (type === "static") {
+                node = node.children[value] ??= { children: {} };
+            }
+            else if (type === "dynamic") {
+                if (!node.children[":"]) {
+                    node.children[":"] = { children: {}, paramName, isOptional };
+                }
+                else if (node.children[":"]?.paramName !== paramName ||
+                    node.children[":"]?.isOptional !== isOptional) {
+                    throw new error_js_1.TezXError(`Conflicting param definition for ${paramName}`);
+                }
+                node = node.children[":"];
+            }
+            else if (type === "wildcard") {
+                node = node.children["*"] ??= { children: {}, paramName };
+                break;
+            }
+        }
+        node.isEndpoint = true;
+        node.handlers ??= {};
+        node.handlers[method] ??= [];
+        node.handlers[method].push(...(handlers || []));
+    }
+    search(method, path) {
+        let params = {};
+        let middlewares = [];
+        const { success, node } = this._match(method, this.root, path?.split("/")?.filter(Boolean), 0, params, middlewares);
+        if (success && node) {
+            const handlers = node.handlers?.[method] ?? [];
+            return { method, params, handlers, middlewares };
+        }
+        return { method, params: {}, handlers: [], middlewares };
+    }
+    _match(method, node, segments, index, params, middlewares) {
+        if (node?.handlers?.ALL) {
+            const mw = node.handlers?.ALL;
+            for (let i = 0; i < mw.length; i++) {
+                middlewares.push(mw[i]);
+            }
+        }
+        if (index === segments.length) {
+            if (node.isEndpoint && node.handlers?.[method])
+                return { success: true, node };
+            const opt = node.children[":"];
+            if (opt?.isOptional) {
+                params[opt.paramName] = null;
+                return this._match(method, opt, segments, index, params, middlewares);
+            }
+            return { success: false, node: node };
+        }
+        const wc = node.children["*"];
+        const seg = segments[index];
+        if (node.children[seg]) {
+            const res = this._match(method, node.children[seg], segments, index + 1, params, middlewares);
+            if (res.success) {
+                if (wc?.handlers?.ALL) {
+                    const mw = wc.handlers?.ALL;
+                    for (let i = 0; i < mw.length; i++) {
+                        middlewares.push(mw[i]);
+                    }
+                }
+                return res;
+            }
+        }
+        const dyn = node.children[":"];
+        if (dyn) {
+            params[dyn.paramName] = seg;
+            const res = this._match(method, dyn, segments, index + 1, params, middlewares);
+            if (res.success) {
+                if (wc?.handlers?.ALL) {
+                    const mw = wc.handlers?.ALL;
+                    for (let i = 0; i < mw.length; i++) {
+                        middlewares.push(mw[i]);
+                    }
+                }
+                return res;
+            }
+            if (dyn.isOptional) {
+                params[dyn.paramName] = null;
+                const skip = this._match(method, dyn, segments, index, params, middlewares);
+                if (skip.success) {
+                    if (wc?.handlers?.ALL) {
+                        const mw = wc.handlers?.ALL;
+                        for (let i = 0; i < mw.length; i++) {
+                            middlewares.push(mw[i]);
+                        }
+                    }
+                    return skip;
+                }
+            }
+        }
+        if (wc) {
+            let wildcard = segments.slice(index).join("/");
+            if (wc?.handlers?.ALL) {
+                const mw = wc.handlers?.ALL;
+                for (let i = 0; i < mw.length; i++) {
+                    middlewares.push(mw[i]);
+                }
+            }
+            if (wildcard) {
+                params[wc.paramName] = wildcard;
+                return { node: wc, success: true };
+            }
+        }
+        return { success: false, node };
+    }
+    parsePattern(pattern) {
+        const segments = (0, index_js_1.sanitizePathSplit)(pattern);
+        const result = [];
+        for (const segment of segments) {
+            if (segment === "*") {
+                result.push({ type: "wildcard", paramName: "*" });
+                break;
+            }
+            else if (segment.startsWith("*")) {
+                const paramName = segment.slice(1) || "*";
+                result.push({ type: "wildcard", paramName });
+                break;
+            }
+            else if (segment.startsWith(":")) {
+                const isOptional = segment.endsWith("?");
+                const paramName = isOptional ? segment.slice(1, -1) : segment.slice(1);
+                result.push({ type: "dynamic", paramName, isOptional });
+            }
+            else {
+                result.push({ type: "static", value: segment });
+            }
+        }
+        return result;
+    }
+}
+exports.RadixRouter = RadixRouter;

package/cjs/registry/index.js

@@ -0,0 +1,17 @@
+"use strict";
+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 __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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./RadixRouter.js"), exports);

package/cjs/types/headers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/index.js

@@ -1,2 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpMethod = void 0;
+exports.httpMethod = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "OPTIONS",
+    "PATCH",
+    "HEAD",
+    "ALL",
+    "TRACE",
+    "CONNECT",
+];

package/cjs/utils/buffer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64Decode = base64Decode;
+function base64Decode(base64) {
+    const pad = base64.length % 4;
+    if (pad)
+        base64 += "=".repeat(4 - pad);
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(base64, "base64").toString("utf-8");
+    }
+    else if (typeof atob === "function") {
+        return new TextDecoder().decode(Uint8Array.from(atob(base64), (c) => c.charCodeAt(0)));
+    }
+    else {
+        throw new Error("Base64 decode not supported in this environment");
+    }
+}

package/cjs/utils/colors.js

@@ -22,6 +22,8 @@ exports.COLORS = {
     bgMagenta: "\x1b[45m",
     bgCyan: "\x1b[46m",
     bgWhite: "\x1b[47m",
+    orange: "\x1b[38;2;255;88;30m",
+    bgOrange: "\x1b[48;2;255;88;30m",
 };
 function colorText(text, color) {
     return `${exports.COLORS[color]}${text}${exports.COLORS.reset}`;

package/cjs/utils/cookie.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCookie = getCookie;
+exports.allCookies = allCookies;
+exports.setCookie = setCookie;
+exports.deleteCookie = deleteCookie;
+function getCookie(ctx, name) {
+    return allCookies(ctx)?.[name];
+}
+function allCookies(ctx) {
+    const cookieHeader = ctx.req.header("cookie");
+    const cookies = {};
+    if (!cookieHeader)
+        return cookies;
+    let start = 0;
+    let sep = -1;
+    const len = cookieHeader.length;
+    for (let i = 0; i <= len; i++) {
+        const ch = cookieHeader.charCodeAt(i) || 59;
+        if (ch === 61 && sep === -1) {
+            sep = i;
+        }
+        else if (ch === 59 || i === len) {
+            if (sep > -1) {
+                const key = cookieHeader.slice(start, sep).trim();
+                const value = cookieHeader.slice(sep + 1, i).trim();
+                cookies[key] = decodeURIComponent(value);
+            }
+            start = i + 1;
+            sep = -1;
+        }
+    }
+    ctx.cookies = cookies;
+    return cookies;
+}
+function setCookie(ctx, name, value, options) {
+    ctx.setHeader("Set-Cookie", `${name}=${value}; ${serializeOptions(options ?? {})}`);
+}
+function deleteCookie(ctx, name, options) {
+    ctx.setHeader("Set-Cookie", `${name}=; ${serializeOptions({ ...options, maxAge: 0, expires: new Date(0) })}`);
+}
+function serializeOptions(options) {
+    const parts = [];
+    if (options.maxAge)
+        parts.push(`Max-Age=${options.maxAge}`);
+    if (options.expires)
+        parts.push(`Expires=${options.expires.toUTCString()}`);
+    if (options.path)
+        parts.push(`Path=${options.path}`);
+    if (options.domain)
+        parts.push(`Domain=${options.domain}`);
+    if (options.secure)
+        parts.push(`Secure`);
+    if (options.httpOnly)
+        parts.push(`HttpOnly`);
+    if (options.sameSite)
+        parts.push(`SameSite=${options.sameSite}`);
+    return parts.join("; ");
+}

package/cjs/utils/file.js

@@ -0,0 +1,136 @@
+"use strict";
+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.fileExists = fileExists;
+exports.getFileBuffer = getFileBuffer;
+exports.readStream = readStream;
+exports.fileSize = fileSize;
+exports.etagDigest = etagDigest;
+const error_js_1 = require("../core/error.js");
+const runtime_js_1 = require("./runtime.js");
+async function fileExists(path) {
+    switch (runtime_js_1.runtime) {
+        case "node": {
+            const { access } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+            try {
+                await access(path);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        case "bun":
+            return Bun.file(path).exists();
+        case "deno":
+            try {
+                await Deno.stat(path);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        default:
+            return false;
+    }
+}
+async function getFileBuffer(path) {
+    switch (runtime_js_1.runtime) {
+        case "node": {
+            const { readFile } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+            return readFile(path);
+        }
+        case "bun": {
+            return new Uint8Array(await Bun.file(path).arrayBuffer());
+        }
+        case "deno":
+            return Deno.readFile(path);
+        default:
+            throw new error_js_1.TezXError("Unsupported runtime environment");
+    }
+}
+async function readStream(path) {
+    switch (runtime_js_1.runtime) {
+        case "node": {
+            const { createReadStream } = await Promise.resolve().then(() => __importStar(require("node:fs")));
+            const { Readable } = await Promise.resolve().then(() => __importStar(require("node:stream")));
+            return Readable.toWeb(createReadStream(path));
+        }
+        case "bun": {
+            return Bun.file(path).stream();
+        }
+        case "deno": {
+            return (await Deno.open(path, { read: true })).readable;
+        }
+        default:
+            throw new error_js_1.TezXError("Unsupported runtime environment");
+    }
+}
+async function fileSize(path) {
+    switch (runtime_js_1.runtime) {
+        case "node": {
+            const { stat } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+            const st = await stat(path);
+            return { size: st.size, mtime: st.mtime };
+        }
+        case "bun": {
+            const st = await Bun.file(path).stat();
+            return { size: st.size, mtime: st.mtime };
+        }
+        case "deno": {
+            const st = await Deno.stat(path);
+            return {
+                size: st.size,
+                mtime: st.mtime ?? new Date(),
+            };
+        }
+        default:
+            throw new error_js_1.TezXError("Unsupported runtime: " + runtime_js_1.runtime);
+    }
+}
+async function etagDigest(algo = "MD5", data) {
+    const encoded = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    if (runtime_js_1.runtime === "bun") {
+        return Bun.hash(data, 256).toString(16);
+    }
+    if (globalThis?.crypto?.subtle) {
+        const buffer = await crypto.subtle.digest(algo, encoded);
+        return Array.from(new Uint8Array(buffer))
+            .map((b) => b.toString(16).padStart(2, "0"))
+            .join("");
+    }
+    const { createHash } = await Promise.resolve().then(() => __importStar(require("node:crypto")));
+    return createHash(algo).update(encoded).digest("hex");
+}