tezx 1.0.73 → 1.0.75-beta

package/utils/formData.js

@@ -1,90 +1,3 @@
-import { GlobalConfig } from "../core/config.js";
-export async function parseJsonBody(req) {
-    const runtime = GlobalConfig.adapter;
-    if (runtime === "node") {
-        return new Promise((resolve, reject) => {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString();
-            });
-            req.on("end", () => {
-                try {
-                    resolve(JSON.parse(body));
-                }
-                catch (error) {
-                    reject(new Error("Invalid JSON format"));
-                }
-            });
-        });
-    }
-    else if (runtime === "deno" || runtime === "bun") {
-        return await req.json();
-    }
-    else {
-        throw new Error("Unsupported environment for multipart parsing");
-    }
-}
-export async function parseTextBody(req) {
-    const runtime = GlobalConfig.adapter;
-    if (runtime === "node") {
-        return new Promise((resolve, reject) => {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString();
-            });
-            req.on("end", () => {
-                try {
-                    resolve(body);
-                }
-                catch (error) {
-                    reject(new Error("Invalid JSON format"));
-                }
-            });
-        });
-    }
-    else if (runtime === "deno" || runtime === "bun") {
-        return await req.text();
-    }
-    else {
-        throw new Error("Unsupported environment for multipart parsing");
-    }
-}
-export async function parseUrlEncodedBody(req) {
-    const runtime = GlobalConfig.adapter;
-    if (runtime === "node") {
-        return new Promise((resolve, reject) => {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString("binary");
-            });
-            req.on("end", () => {
-                try {
-                    const pairs = body.split("&");
-                    const formData = {};
-                    pairs.forEach((pair) => {
-                        const [key, value] = pair.split("=");
-                        formData[decodeURIComponent(key)] = decodeURIComponent(value || "");
-                    });
-                    resolve(formData);
-                }
-                catch {
-                    reject(new Error("Invalid x-www-form-urlencoded format"));
-                }
-            });
-        });
-    }
-    else if (runtime === "deno" || runtime === "bun") {
-        const formData = await req.formData();
-        const result = {};
-        for (const [key, value] of formData.entries()) {
-            result[key] = value;
-        }
-        return result;
-    }
-    else {
-        throw new Error("Unsupported environment for multipart parsing");
-    }
-}
 export function sanitized(title) {
     const base = title
         .toLowerCase()
@@ -95,147 +8,3 @@ export function sanitized(title) {
         .replace(/^-+|-+$/g, "");
     return base;
 }
-export async function parseMultipartBody(req, boundary, options) {
-    const runtime = GlobalConfig.adapter;
-    if (runtime === "node") {
-        return new Promise((resolve, reject) => {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString("binary");
-            });
-            req.on("end", () => {
-                try {
-                    const formDataField = {};
-                    const formDataFieldParts = body.split("----------------------------");
-                    formDataFieldParts.forEach((part) => {
-                        const match = part.match(/name="(.*)"\r\n\r\n(.*)\r\n/);
-                        if (match && match.length === 3) {
-                            const name = match[1];
-                            const value = match[2];
-                            if (formDataField[name]) {
-                                if (Array.isArray(formDataField[name])) {
-                                    formDataField[name].push(value);
-                                }
-                                else {
-                                    formDataField[name] = [formDataField[name], value];
-                                }
-                            }
-                            else {
-                                formDataField[name] = value;
-                            }
-                        }
-                    });
-                    const parts = body.split(`--${boundary}`);
-                    for (const part of parts) {
-                        if (part.includes("filename")) {
-                            const filenameMatch = part.match(/filename="([^"]+)"/);
-                            const fieldNameMatch = part.match(/name="([^"]+)"/);
-                            const contentTypeMatch = part.match(/Content-Type: ([^\r\n]+)/);
-                            if (filenameMatch && fieldNameMatch && contentTypeMatch) {
-                                let filename = filenameMatch[1];
-                                const fieldName = fieldNameMatch[1];
-                                const contentType = contentTypeMatch[1];
-                                if (options?.sanitized) {
-                                    filename = `${Date.now()}-${sanitized(filename)}`;
-                                }
-                                if (Array.isArray(options?.allowedTypes) &&
-                                    !options.allowedTypes?.includes(contentType)) {
-                                    reject(new Error(`Invalid file type: "${contentType}". Allowed types: ${options.allowedTypes.join(", ")}`));
-                                }
-                                const fileContentStartIndex = part.indexOf("\r\n\r\n") + 4;
-                                const fileContent = Buffer.from(part.substring(fileContentStartIndex), "binary");
-                                const arrayBuffer = fileContent.buffer.slice(fileContent.byteOffset, fileContent.byteOffset + fileContent.byteLength);
-                                if (typeof options?.maxSize !== "undefined" &&
-                                    fileContent.byteLength > options.maxSize) {
-                                    reject(new Error(`File size exceeds the limit: ${fileContent.byteLength} bytes (Max: ${options.maxSize} bytes)`));
-                                }
-                                const file = new File([arrayBuffer], filename, {
-                                    type: contentType,
-                                });
-                                if (typeof options?.maxFiles != "undefined" &&
-                                    options.maxFiles == 0) {
-                                    reject(new Error(`Field "${fieldName}" exceeds the maximum allowed file count of ${options.maxFiles}.`));
-                                }
-                                if (formDataField[fieldName]) {
-                                    if (Array.isArray(formDataField[fieldName])) {
-                                        const existingFiles = formDataField[fieldName].filter((f) => f instanceof File);
-                                        if (typeof options?.maxFiles != "undefined" &&
-                                            existingFiles.length >= options.maxFiles) {
-                                            reject(new Error(`Field "${fieldName}" exceeds the maximum allowed file count of ${options.maxFiles}.`));
-                                        }
-                                        formDataField[fieldName].push(file);
-                                    }
-                                    else {
-                                        if (formDataField[fieldName] instanceof File &&
-                                            typeof options?.maxFiles != "undefined" &&
-                                            options.maxFiles == 1) {
-                                            reject(new Error(`Field "${fieldName}" exceeds the maximum allowed file count of ${options.maxFiles}.`));
-                                        }
-                                        formDataField[fieldName] = [formDataField[fieldName], file];
-                                    }
-                                }
-                                else {
-                                    formDataField[fieldName] = file;
-                                }
-                            }
-                        }
-                    }
-                    resolve(formDataField);
-                }
-                catch { }
-            });
-        });
-    }
-    else if (runtime === "deno" || runtime === "bun") {
-        const formData = await req.formData();
-        const result = {};
-        for (const [key, value] of formData.entries()) {
-            let val = value;
-            if (val instanceof File && typeof options == "object") {
-                let filename = val.name;
-                if (options?.sanitized) {
-                    filename = `${Date.now()}-${sanitized(filename)}`;
-                }
-                if (Array.isArray(options?.allowedTypes) &&
-                    !options.allowedTypes?.includes(val.type)) {
-                    throw new Error(`Invalid file type: "${val.type}". Allowed types: ${options.allowedTypes.join(", ")}`);
-                }
-                if (typeof options?.maxSize !== "undefined" &&
-                    val.size > options.maxSize) {
-                    throw new Error(`File size exceeds the limit: ${val.size} bytes (Max: ${options.maxSize} bytes)`);
-                }
-                if (typeof options?.maxFiles != "undefined" && options.maxFiles == 0) {
-                    throw new Error(`Field "${key}" exceeds the maximum allowed file count of ${options.maxFiles}.`);
-                }
-                val = new File([await val.arrayBuffer()], filename, {
-                    type: val.type,
-                });
-            }
-            if (result[key]) {
-                if (Array.isArray(result[key])) {
-                    if (val instanceof File &&
-                        typeof options?.maxFiles != "undefined" &&
-                        result[key]?.length >= options.maxFiles) {
-                        throw new Error(`Field "${key}" exceeds the maximum allowed file count of ${options.maxFiles}.`);
-                    }
-                    result[key].push(val);
-                }
-                else {
-                    if (val instanceof File &&
-                        typeof options?.maxFiles != "undefined" &&
-                        options.maxFiles == 1) {
-                        throw new Error(`Field "${key}" exceeds the maximum allowed file count of ${options.maxFiles}.`);
-                    }
-                    result[key] = [result[key], val];
-                }
-            }
-            else {
-                result[key] = val;
-            }
-        }
-        return result;
-    }
-    else {
-        throw new Error("Unsupported environment for multipart parsing");
-    }
-}

package/utils/httpStatusMap.d.ts

@@ -0,0 +1 @@
+export declare const httpStatusMap: Record<number, string>;

package/utils/httpStatusMap.js

@@ -0,0 +1,65 @@
+export const httpStatusMap = {
+    100: "Continue",
+    101: "Switching Protocols",
+    102: "Processing",
+    103: "Early Hints",
+    200: "OK",
+    201: "Created",
+    202: "Accepted",
+    203: "Non-Authoritative Information",
+    204: "No Content",
+    205: "Reset Content",
+    206: "Partial Content",
+    207: "Multi-Status",
+    208: "Already Reported",
+    226: "IM Used",
+    300: "Multiple Choices",
+    301: "Moved Permanently",
+    302: "Found",
+    303: "See Other",
+    304: "Not Modified",
+    305: "Use Proxy",
+    306: "Switch Proxy",
+    307: "Temporary Redirect",
+    308: "Permanent Redirect",
+    400: "Bad Request",
+    401: "Unauthorized",
+    402: "Payment Required",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    406: "Not Acceptable",
+    407: "Proxy Authentication Required",
+    408: "Request Timeout",
+    409: "Conflict",
+    410: "Gone",
+    411: "Length Required",
+    412: "Precondition Failed",
+    413: "Payload Too Large",
+    414: "URI Too Long",
+    415: "Unsupported Media Type",
+    416: "Range Not Satisfiable",
+    417: "Expectation Failed",
+    418: "I'm a Teapot",
+    421: "Misdirected Request",
+    422: "Unprocessable Entity",
+    423: "Locked",
+    424: "Failed Dependency",
+    425: "Too Early",
+    426: "Upgrade Required",
+    428: "Precondition Required",
+    429: "Too Many Requests",
+    431: "Request Header Fields Too Large",
+    451: "Unavailable For Legal Reasons",
+    500: "Internal Server Error",
+    501: "Not Implemented",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout",
+    505: "HTTP Version Not Supported",
+    506: "Variant Also Negotiates",
+    507: "Insufficient Storage",
+    508: "Loop Detected",
+    510: "Not Extended",
+    511: "Network Authentication Required",
+};

package/utils/staticFile.js

@@ -145,7 +145,10 @@ export async function getFiles(dir, basePath = "/", ref, option) {
                 ctx.headers.set("Cache-Control", option.cacheControl);
             }
             if (option.headers) {
-                ctx.headers.add(option.headers);
+                for (const key in option.headers) {
+                    let value = option.headers?.[key];
+                    ctx.headers.set(key, value);
+                }
             }
             return ctx.sendFile(r.file);
         });

package/utils/toWebRequest.d.ts

@@ -0,0 +1,11 @@
+import { IncomingMessage } from "node:http";
+/**
+ * Convert Node.js IncomingMessage to a standard Web Fetch API Request with full support:
+ * - Absolute URL resolution
+ * - Streaming body (duplex)
+ * - AbortSignal linked to client disconnect
+ *
+ * @param {IncomingMessage} req Node.js HTTP request object
+ * @returns {Request} Web Fetch API Request instance
+ */
+export declare function toWebRequest(req: IncomingMessage, method?: string): Request;

package/utils/toWebRequest.js

@@ -0,0 +1,32 @@
+import { Readable } from "node:stream";
+export function toWebRequest(req, method = "GET") {
+    const headers = {};
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (Array.isArray(value)) {
+            headers[key] = value.join(", ");
+        }
+        else if (typeof value === "string") {
+            headers[key] = value;
+        }
+    }
+    const isEncrypted = (req.socket && req.socket.encrypted) || false;
+    const protocol = isEncrypted ? "https:" : "http:";
+    let host = "localhost";
+    const hostHeader = req.headers.host;
+    if (typeof hostHeader === "string") {
+        host = hostHeader;
+    }
+    const urlStr = req.url ?? "/";
+    const fullUrl = new URL(urlStr, `${protocol}//${host}`);
+    const hasBody = !["GET", "HEAD"].includes(method.toUpperCase());
+    const body = hasBody ? Readable.toWeb(req) : undefined;
+    const abortController = new AbortController();
+    req?.once("close", () => abortController.abort());
+    return new Request(fullUrl.href, {
+        method,
+        headers,
+        body,
+        signal: abortController.signal,
+        duplex: hasBody ? "half" : undefined,
+    });
+}

package/adapter/node.d.ts

@@ -1,19 +0,0 @@
-import type { ServerOptions } from "node:http";
-import type { TlsOptions } from "node:tls";
-import { TezX } from "../core/server.js";
-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/cjs/core/header.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HeadersParser = void 0;
-class HeadersParser {
-    headers = new Map();
-    constructor(init) {
-        if (init) {
-            this.add(init);
-        }
-    }
-    add(headers) {
-        if (Array.isArray(headers)) {
-            for (const [key, value] of headers) {
-                this.set(key, value);
-            }
-        }
-        else if (typeof Headers !== "undefined" && headers instanceof Headers) {
-            for (const [key, value] of headers.entries()) {
-                this.set(key, value);
-            }
-        }
-        else if (typeof headers === "object") {
-            for (const key in headers) {
-                if (Object.prototype.hasOwnProperty.call(headers, key)) {
-                    this.set(key, headers[key]);
-                }
-            }
-        }
-        return this;
-    }
-    set(key, value) {
-        this.headers.set(key.toLowerCase(), Array.isArray(value) ? value : [value]);
-        return this;
-    }
-    clear() {
-        this.headers.clear();
-        return this;
-    }
-    get(key) {
-        const values = this.headers.get(key.toLowerCase());
-        return values ? values[0] : undefined;
-    }
-    getAll(key) {
-        return this.headers.get(key.toLowerCase()) || [];
-    }
-    has(key) {
-        return this.headers.has(key.toLowerCase());
-    }
-    delete(key) {
-        return this.headers.delete(key.toLowerCase());
-    }
-    append(key, value) {
-        const lowerKey = key.toLowerCase();
-        if (this.headers.has(lowerKey)) {
-            this.headers.get(lowerKey).push(value);
-        }
-        else {
-            this.headers.set(lowerKey, [value]);
-        }
-        return this;
-    }
-    entries() {
-        return this.headers.entries();
-    }
-    keys() {
-        return this.headers.keys();
-    }
-    values() {
-        return this.headers.values();
-    }
-    forEach(callback) {
-        for (const [key, value] of this.headers) {
-            callback(value, key);
-        }
-    }
-    toObject() {
-        const obj = {};
-        for (const [key, value] of this.headers.entries()) {
-            obj[key] = value.length > 1 ? value : value[0];
-        }
-        return obj;
-    }
-    toJSON() {
-        const obj = {};
-        for (const [key, value] of this.headers.entries()) {
-            obj[key] = Array.isArray(value) ? value.join(", ") : value;
-        }
-        return obj;
-    }
-}
-exports.HeadersParser = HeadersParser;
-Object.defineProperty(HeadersParser, "name", { value: "Headers" });

package/core/header.d.ts

@@ -1,77 +0,0 @@
-export declare class HeadersParser {
-    private headers;
-    constructor(init?: [string, string | string[]][] | Record<string, string>);
-    /**
-     * Adds multiple headers to the parser.
-     * @param headers - Headers as an array of tuples or a record object.
-     */
-    add(headers: [string, string | string[]][] | Record<string, string>): this;
-    /**
-     * Sets a header value.
-     * @param key - Header name.
-     * @param value - Header value(s).
-     */
-    set(key: string, value: string | string[]): this;
-    clear(): this;
-    /**
-     * Retrieves the first value of a header.
-     * @param key - Header name.
-     * @returns The first header value or undefined if not found.
-     */
-    get(key: string): string | undefined;
-    /**
-     * Retrieves all values of a header.
-     * @param key - Header name.
-     * @returns An array of header values.
-     */
-    getAll(key: string): string[];
-    /**
-     * Checks if a header exists.
-     * @param key - Header name.
-     * @returns True if the header exists, false otherwise.
-     */
-    has(key: string): boolean;
-    /**
-     * Deletes a header.
-     * @param key - Header name.
-     * @returns True if deleted successfully, false otherwise.
-     */
-    delete(key: string): boolean;
-    /**
-     * Appends a value to an existing header or creates a new one.
-     * @param key - Header name.
-     * @param value - Value to append.
-     */
-    append(key: string, value: string): this;
-    /**
-     * Returns an iterator over header entries.
-     * @returns IterableIterator of header key-value pairs.
-     */
-    entries(): IterableIterator<[string, string[]]>;
-    /**
-     * Returns an iterator over header keys.
-     * @returns IterableIterator of header names.
-     */
-    keys(): IterableIterator<string>;
-    /**
-     * Returns an iterator over header values.
-     * @returns IterableIterator of header values arrays.
-     */
-    values(): IterableIterator<string[]>;
-    /**
-     * Iterates over headers and executes a callback function.
-     * @param callback - Function to execute for each header.
-     */
-    forEach(callback: (value: string[], key: string) => void): void;
-    /**
-     * Converts headers into a plain object.
-     * @returns A record of headers where single-value headers are returned as a string.
-     */
-    toObject(): Record<string, string | string[]>;
-    /**
-     * Converts headers to a JSON-safe plain object (only single string values).
-     * Multi-value headers are joined by commas.
-     * @returns A record of headers with string values.
-     */
-    toJSON(): Record<string, string>;
-}

package/core/header.js

@@ -1,88 +0,0 @@
-export class HeadersParser {
-    headers = new Map();
-    constructor(init) {
-        if (init) {
-            this.add(init);
-        }
-    }
-    add(headers) {
-        if (Array.isArray(headers)) {
-            for (const [key, value] of headers) {
-                this.set(key, value);
-            }
-        }
-        else if (typeof Headers !== "undefined" && headers instanceof Headers) {
-            for (const [key, value] of headers.entries()) {
-                this.set(key, value);
-            }
-        }
-        else if (typeof headers === "object") {
-            for (const key in headers) {
-                if (Object.prototype.hasOwnProperty.call(headers, key)) {
-                    this.set(key, headers[key]);
-                }
-            }
-        }
-        return this;
-    }
-    set(key, value) {
-        this.headers.set(key.toLowerCase(), Array.isArray(value) ? value : [value]);
-        return this;
-    }
-    clear() {
-        this.headers.clear();
-        return this;
-    }
-    get(key) {
-        const values = this.headers.get(key.toLowerCase());
-        return values ? values[0] : undefined;
-    }
-    getAll(key) {
-        return this.headers.get(key.toLowerCase()) || [];
-    }
-    has(key) {
-        return this.headers.has(key.toLowerCase());
-    }
-    delete(key) {
-        return this.headers.delete(key.toLowerCase());
-    }
-    append(key, value) {
-        const lowerKey = key.toLowerCase();
-        if (this.headers.has(lowerKey)) {
-            this.headers.get(lowerKey).push(value);
-        }
-        else {
-            this.headers.set(lowerKey, [value]);
-        }
-        return this;
-    }
-    entries() {
-        return this.headers.entries();
-    }
-    keys() {
-        return this.headers.keys();
-    }
-    values() {
-        return this.headers.values();
-    }
-    forEach(callback) {
-        for (const [key, value] of this.headers) {
-            callback(value, key);
-        }
-    }
-    toObject() {
-        const obj = {};
-        for (const [key, value] of this.headers.entries()) {
-            obj[key] = value.length > 1 ? value : value[0];
-        }
-        return obj;
-    }
-    toJSON() {
-        const obj = {};
-        for (const [key, value] of this.headers.entries()) {
-            obj[key] = Array.isArray(value) ? value.join(", ") : value;
-        }
-        return obj;
-    }
-}
-Object.defineProperty(HeadersParser, "name", { value: "Headers" });