tezx 1.0.74 → 1.0.75-beta

package/cjs/utils/formData.js

@@ -1,97 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJsonBody = parseJsonBody;
-exports.parseTextBody = parseTextBody;
-exports.parseUrlEncodedBody = parseUrlEncodedBody;
 exports.sanitized = sanitized;
-exports.parseMultipartBody = parseMultipartBody;
-const config_js_1 = require("../core/config.js");
-async function parseJsonBody(req) {
-    const runtime = config_js_1.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");
-    }
-}
-async function parseTextBody(req) {
-    const runtime = config_js_1.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");
-    }
-}
-async function parseUrlEncodedBody(req) {
-    const runtime = config_js_1.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");
-    }
-}
 function sanitized(title) {
     const base = title
         .toLowerCase()
@@ -102,147 +11,3 @@ function sanitized(title) {
         .replace(/^-+|-+$/g, "");
     return base;
 }
-async function parseMultipartBody(req, boundary, options) {
-    const runtime = config_js_1.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/cjs/utils/httpStatusMap.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpStatusMap = void 0;
+exports.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/cjs/utils/staticFile.js

@@ -149,7 +149,10 @@ 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/cjs/utils/toWebRequest.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toWebRequest = toWebRequest;
+const node_stream_1 = require("node:stream");
+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 ? node_stream_1.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/core/context.d.ts

@@ -1,6 +1,5 @@
 import { State } from "../utils/state.js";
-import { HeadersParser } from "./header.js";
-import { HTTPMethod, Request } from "./request.js";
+import { HTTPMethod, Request as RequestParser } from "./request.js";
 import { TezXServeOptions } from "./server.js";
 export interface CookieOptions {
     expires?: Date;
@@ -11,11 +10,11 @@ export interface CookieOptions {
     httpOnly?: boolean;
     sameSite?: "Strict" | "Lax" | "None";
 }
-export declare const httpStatusMap: Record<number, string>;
 export type ResponseHeaders = Record<string, string>;
 export declare class Context<T extends Record<string, any> = {}> {
     #private;
     [key: string]: any;
+    rawRequest: Request;
     /**
      * Environment variables and configuration
      * @type {object}
@@ -23,9 +22,9 @@ export declare class Context<T extends Record<string, any> = {}> {
     env: Record<string, any> & T;
     /**
      * Parser for handling and manipulating HTTP headers
-     * @type {HeadersParser}
+     * @type {Headers}
      */
-    headers: HeadersParser;
+    headers: Headers;
     /**
      * Request path without query parameters
      * @type {string}
@@ -193,7 +192,7 @@ export declare class Context<T extends Record<string, any> = {}> {
      * // Access route params
      * const id = request.params.get('id');
      */
-    get req(): Request;
+    get req(): RequestParser;
     protected set params(params: Record<string, any>);
     /**
      * Set response body to be passed between middlewares or returned as final output.

package/core/context.js

@@ -1,79 +1,13 @@
 import { State } from "../utils/state.js";
 import { defaultMimeType, mimeTypes } from "../utils/staticFile.js";
-import { urlParse } from "../utils/url.js";
+import { toWebRequest } from "../utils/toWebRequest.js";
 import { GlobalConfig } from "./config.js";
 import { EnvironmentDetector } from "./environment.js";
-import { HeadersParser } from "./header.js";
-import { Request } from "./request.js";
-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",
-};
+import { Request as RequestParser } from "./request.js";
 export class Context {
-    #rawRequest;
+    rawRequest;
     env = {};
-    headers = new HeadersParser();
+    headers = new Headers();
     pathname;
     url;
     method;
@@ -82,30 +16,20 @@ export class Context {
     #params = {};
     resBody;
     #body;
-    #urlRef;
-    #requestHeaders;
     #options;
     constructor(req, options) {
         this.#options = options;
-        this.#rawRequest = req;
         this.method = req?.method?.toUpperCase();
-        this.#requestHeaders = new HeadersParser(req?.headers);
         if (GlobalConfig.adapter == "node") {
-            let encrypted = req?.socket?.encrypted;
-            const protocol = typeof encrypted === "boolean"
-                ? encrypted
-                    ? "https"
-                    : "http"
-                : "http";
-            const host = EnvironmentDetector.getHost(this.#requestHeaders);
-            const path = req.url || "/";
-            this.url = `${protocol}://${host}${path}`;
+            let request = toWebRequest(req, this.method);
+            this.url = request.url;
+            this.rawRequest = request;
         }
         else {
             this.url = req.url;
+            this.rawRequest = req;
         }
-        this.#urlRef = urlParse(this.url);
-        this.pathname = this.#urlRef.pathname;
+        this.pathname = this.req.urlRef.pathname;
     }
     header(key, value, options) {
         let append = options?.append;
@@ -118,16 +42,9 @@ export class Context {
         return this;
     }
     get cookies() {
-        const c = this.#requestHeaders.getAll("cookie");
+        const c = this.req.headers.get("cookie");
         let cookies = {};
-        if (Array.isArray(c) && c.length != 0) {
-            const cookieHeader = c.join("; ").split(";");
-            for (const pair of cookieHeader) {
-                const [key, value] = pair?.trim()?.split("=");
-                cookies[key] = decodeURIComponent(value);
-            }
-        }
-        else if (typeof c == "string") {
+        if (typeof c == "string") {
             const cookieHeader = c.split(";");
             for (const pair of cookieHeader) {
                 const [key, value] = pair?.trim()?.split("=");
@@ -418,10 +335,9 @@ export class Context {
         return response;
     }
     get req() {
-        return new Request({
-            headers: this.#requestHeaders,
-            req: this.#rawRequest,
-            urlRef: this.#urlRef,
+        return new RequestParser({
+            method: this.method,
+            req: this.rawRequest,
             options: this.#options,
             params: this.#params,
         });

package/core/environment.d.ts

@@ -1,5 +1,3 @@
-import { HeadersParser } from "./header.js";
 export declare class EnvironmentDetector {
     static get getEnvironment(): "node" | "bun" | "deno" | "unknown";
-    static getHost(headers: HeadersParser): string;
 }

package/core/environment.js

@@ -8,12 +8,4 @@ export class EnvironmentDetector {
             return "node";
         return "unknown";
     }
-    static getHost(headers) {
-        try {
-            return headers?.get("host") || "unknown";
-        }
-        catch (error) {
-            throw new Error("Failed to get host.");
-        }
-    }
 }