tezx 2.0.11 → 3.0.0

package/core/context.js

@@ -1,388 +1,173 @@
-import { State } from "../utils/state.js";
-import { defaultMimeType, mimeTypes } from "../utils/staticFile.js";
-import { toWebRequest } from "../utils/toWebRequest.js";
-import { GlobalConfig } from "./config.js";
-import { Environment } from "./environment.js";
-import { Request as RequestParser } from "./request.js";
+import { fileExists, fileSize, getFileBuffer, readStream, } from "../utils/file.js";
+import { extensionExtract } from "../utils/low-level.js";
+import { defaultMimeType, mimeTypes } from "../utils/mimeTypes.js";
+import { determineContentTypeBody, toString } from "../utils/response.js";
+import { TezXError } from "./error.js";
+import { TezXRequest } from "./request.js";
 export class Context {
+    #status = 200;
+    #headers;
+    #req = null;
+    #params = {};
     rawRequest;
+    #args;
+    #body;
+    url;
+    res;
     env = {};
-    headers = new Headers();
     pathname;
-    url;
     method;
-    #status = 200;
-    state = new State();
-    #params = {};
-    resBody;
-    #body;
-    #options;
-    constructor(req, options) {
-        this.#options = options;
-        this.method = req?.method?.toUpperCase();
-        if (GlobalConfig.adapter == "node") {
-            let request = toWebRequest(req, this.method);
-            this.url = request.url;
-            this.rawRequest = request;
-        }
-        else {
-            this.url = req.url;
-            this.rawRequest = req;
-        }
-        this.pathname = this.req.urlRef.pathname;
+    constructor(req, pathname, method, env, args) {
+        this.#args = args;
+        this.rawRequest = req;
+        this.url = req.url;
+        this.pathname = pathname;
+        this.env = env ?? {};
+        this.method = method;
+    }
+    get getStatus() {
+        return this.#status;
+    }
+    set setStatus(code) {
+        this.#status = code;
     }
-    header(key, value, options) {
-        let append = options?.append;
+    get headers() {
+        return this.res?.headers ?? (this.#headers ??= new Headers());
+    }
+    setHeader(key, value, options) {
+        if (!value)
+            return this;
+        const _key = key.toLowerCase();
+        const append = options?.append || _key === "set-cookie";
+        const target = this.res?.headers ?? (this.#headers ??= new Headers());
         if (append) {
-            this.headers.append(key, value);
+            target.append(_key, value);
         }
         else {
-            this.headers.set(key, value);
+            target.set(_key, value);
         }
         return this;
     }
-    get cookies() {
-        const c = this.req.headers.get("cookie");
-        let cookies = {};
-        if (typeof c == "string") {
-            const cookieHeader = c.split(";");
-            for (const pair of cookieHeader) {
-                const [key, value] = pair?.trim()?.split("=");
-                cookies[key] = decodeURIComponent(value);
-            }
-        }
-        return {
-            get: (cookie) => {
-                return cookies?.[cookie];
-            },
-            all: () => {
-                return cookies;
-            },
-            delete: (name, options) => {
-                const value = "";
-                const cookieOptions = {
-                    ...options,
-                    expires: new Date(0),
-                };
-                const cookieHeader = `${name}=${value};${serializeOptions(cookieOptions)}`;
-                this.headers.set("Set-Cookie", cookieHeader);
-            },
-            set: (name, value, options) => {
-                const cookieHeader = `${name}=${value};${serializeOptions(options || {})}`;
-                this.headers.set("Set-Cookie", cookieHeader);
-            },
-        };
-    }
-    json(body, ...args) {
-        let status = this.#status;
-        let headers = {
-            "Content-Type": "application/json; charset=utf-8",
-        };
-        if (typeof args[0] === "number") {
-            status = args[0];
-            if (typeof args[1] === "object") {
-                headers = { ...headers, ...args[1] };
-            }
-        }
-        else if (typeof args[0] === "object") {
-            headers = { ...headers, ...args[0] };
-        }
-        return this.#handleResponse(JSON.stringify(body), {
-            status: status,
-            headers: headers,
-        });
-    }
-    send(body, ...args) {
-        let status = this.#status;
-        let headers = {};
-        if (typeof args[0] === "number") {
-            status = args[0];
-            if (typeof args[1] === "object") {
-                headers = args[1];
-            }
-        }
-        else if (typeof args[0] === "object") {
-            headers = args[0];
-        }
-        const contentTypeHeader = headers["Content-Type"] || headers["content-type"] || "";
-        if (!contentTypeHeader) {
-            if (typeof body === "string") {
-                headers["Content-Type"] = "text/plain; charset=utf-8";
-            }
-            else if (typeof body === "number" || typeof body === "boolean") {
-                headers["Content-Type"] = "text/plain; charset=utf-8";
-            }
-            else if (typeof body === "object" &&
-                body !== null &&
-                !(body instanceof ReadableStream)) {
-                headers["Content-Type"] = "application/json; charset=utf-8";
-                body = JSON.stringify(body);
-            }
-            else {
-                headers["Content-Type"] = "application/octet-stream";
-            }
-        }
-        return this.#handleResponse(body, {
-            status: status,
-            headers,
-        });
+    set params(params) {
+        this.#params = params;
     }
-    html(strings, ...args) {
-        let status = this.#status;
-        let data = strings;
-        if (Array.isArray(strings)) {
-            data = strings.reduce((result, str, i) => {
-                const value = args?.[i] ?? "";
-                return result + str + value;
-            }, "");
-        }
-        let headers = {
-            "Content-Type": "text/html; charset=utf-8",
-        };
-        if (typeof args[0] === "number") {
-            status = args[0];
-            if (typeof args[1] === "object") {
-                headers = { ...headers, ...args[1] };
-            }
-        }
-        else if (typeof args[0] === "object") {
-            headers = { ...headers, ...args[0] };
-        }
-        return this.#handleResponse(data, {
-            status: status,
-            headers: headers,
-        });
+    get req() {
+        return (this.#req ??= new TezXRequest(this.rawRequest, this.method, this.pathname, this.#params));
     }
-    text(data, ...args) {
-        let status = this.#status;
-        let headers = {
-            "Content-Type": "text/plain; charset=utf-8",
-        };
-        if (typeof args[0] === "number") {
-            status = args[0];
-            if (typeof args[1] === "object") {
-                headers = { ...headers, ...args[1] };
-            }
-        }
-        else if (typeof args[0] === "object") {
-            headers = { ...headers, ...args[0] };
-        }
-        return this.#handleResponse(data, {
-            status: status,
-            headers: headers,
-        });
+    get body() {
+        return this.#body;
     }
-    xml(data, ...args) {
-        let status = this.#status;
-        let headers = {
-            "Content-Type": "application/xml; charset=utf-8",
-        };
-        if (typeof args[0] === "number") {
-            status = args[0];
-            if (typeof args[1] === "object") {
-                headers = { ...headers, ...args[1] };
-            }
-        }
-        else if (typeof args[0] === "object") {
-            headers = { ...headers, ...args[0] };
-        }
-        return this.#handleResponse(data, {
-            status: status,
-            headers: headers,
-        });
+    set body(value) {
+        this.#body = value;
     }
     status = (status) => {
         this.#status = status;
         return this;
     };
-    set setStatus(status) {
-        this.#status = status;
-    }
-    get getStatus() {
-        return this.#status;
-    }
-    redirect(url, status = 302) {
-        return new Response(null, {
-            status: status,
-            headers: { Location: url },
-        });
-    }
-    async download(filePath, fileName) {
-        try {
-            let fileExists = false;
-            const runtime = Environment.getEnvironment;
-            if (runtime === "node") {
-                const { existsSync } = await import("node:fs");
-                fileExists = existsSync(filePath);
-            }
-            else if (runtime === "bun") {
-                fileExists = Bun.file(filePath).exists();
-            }
-            else if (runtime === "deno") {
-                try {
-                    await Deno.stat(filePath);
-                    fileExists = true;
+    #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);
                 }
-                catch {
-                    fileExists = false;
+                else {
+                    headers.set(key, value);
                 }
             }
-            if (!fileExists) {
-                throw Error("File not found");
-            }
-            let fileBuffer;
-            if (runtime === "node") {
-                const { readFileSync } = await import("node:fs");
-                fileBuffer = await readFileSync(filePath);
-            }
-            else if (runtime === "bun") {
-                fileBuffer = await Bun.file(filePath)
-                    .arrayBuffer()
-                    .then((buf) => new Uint8Array(buf));
-            }
-            else if (runtime === "deno") {
-                fileBuffer = await Deno.readFile(filePath);
-            }
-            return this.#handleResponse(fileBuffer, {
-                status: 200,
-                headers: {
-                    "Content-Disposition": `attachment; filename="${fileName}"`,
-                    "Content-Type": "application/octet-stream",
-                    "Content-Length": fileBuffer.byteLength.toString(),
-                },
-            });
-        }
-        catch (error) {
-            throw Error("Internal Server Error" + error?.message);
         }
+        return new Response(body, {
+            status: init.status ?? this.#status,
+            statusText: init.statusText,
+            headers,
+        });
     }
-    async sendFile(filePath, ...args) {
-        try {
-            const runtime = Environment.getEnvironment;
-            const resolvedPath = filePath;
-            let fileExists = false;
-            if (runtime === "node") {
-                const { existsSync } = await import("node:fs");
-                fileExists = existsSync(resolvedPath);
-            }
-            else if (runtime === "bun") {
-                fileExists = Bun.file(resolvedPath).exists();
-            }
-            else if (runtime === "deno") {
-                try {
-                    await Deno.stat(resolvedPath);
-                    fileExists = true;
+    newResponse(body, init = {}) {
+        const headers = new Headers(this.#headers);
+        if (init.headers) {
+            for (const key in init.headers) {
+                const value = init.headers[key];
+                if (!value) {
+                    continue;
                 }
-                catch {
-                    fileExists = false;
+                if (key.toLowerCase() === "set-cookie") {
+                    headers.append(key, value);
                 }
-            }
-            if (!fileExists) {
-                throw Error("File not found");
-            }
-            let fileSize = 0;
-            if (runtime === "node") {
-                const { statSync } = await import("node:fs");
-                fileSize = statSync(resolvedPath).size;
-            }
-            else if (runtime === "bun") {
-                fileSize = (await Bun.file(resolvedPath).arrayBuffer()).byteLength;
-            }
-            else if (runtime === "deno") {
-                const fileInfo = await Deno.stat(resolvedPath);
-                fileSize = fileInfo.size;
-            }
-            const ext = filePath.split(".").pop()?.toLowerCase() || "";
-            const mimeType = mimeTypes[ext] || defaultMimeType;
-            let fileStream;
-            if (runtime === "node") {
-                const { createReadStream } = await import("node:fs");
-                fileStream = createReadStream(resolvedPath);
-            }
-            else if (runtime === "bun") {
-                fileStream = Bun.file(resolvedPath).stream();
-            }
-            else if (runtime === "deno") {
-                const file = await Deno.open(resolvedPath, { read: true });
-                fileStream = file.readable;
-            }
-            let headers = {
-                "Content-Type": mimeType,
-                "Content-Length": fileSize.toString(),
-            };
-            let fileName = "";
-            if (typeof args[0] === "string") {
-                fileName = args[0];
-                if (typeof args[1] === "object") {
-                    headers = { ...headers, ...args[1] };
+                else {
+                    headers.set(key, value);
                 }
             }
-            else if (typeof args[0] === "object") {
-                headers = { ...headers, ...args[0] };
-            }
-            if (fileName) {
-                headers["Content-Disposition"] = `attachment; filename="${fileName}"`;
-            }
-            return this.#handleResponse(fileStream, {
-                status: 200,
-                headers,
-            });
-        }
-        catch (error) {
-            throw Error("Internal Server Error" + error?.message);
         }
-    }
-    #handleResponse(body, { headers, status }) {
-        let response = new Response(body, {
-            status: status,
+        return new Response(body, {
+            status: init.status ?? this.#status,
+            statusText: init.statusText,
             headers,
         });
-        this.resBody = body;
-        return response;
-    }
-    get req() {
-        return new RequestParser({
-            method: this.method,
-            req: this.rawRequest,
-            options: this.#options,
-            params: this.#params,
-        });
-    }
-    set params(params) {
-        this.#params = params;
-    }
-    set body(body) {
-        this.#body = body;
     }
-    get body() {
-        return this.#body;
+    text(content, init) {
+        return this.#newResponse(content, "text/plain; charset=utf-8", init);
     }
-    get params() {
-        return this.#params;
-    }
-}
-function serializeOptions(options) {
-    const parts = [];
-    if (options.maxAge) {
-        parts.push(`Max-Age=${options.maxAge}`);
+    html(strings, ...args) {
+        return this.#newResponse(toString(strings, args), "text/html; charset=utf-8", args?.[0]);
     }
-    if (options.expires) {
-        parts.push(`Expires=${options.expires.toUTCString()}`);
+    xml(strings, ...args) {
+        return this.#newResponse(toString(strings, args), "text/html; charset=utf-8", args?.[0]);
     }
-    if (options.path) {
-        parts.push(`Path=${options.path}`);
+    json(json, init) {
+        return this.#newResponse(JSON.stringify(json), "application/json; charset=utf-8", init);
     }
-    if (options.domain) {
-        parts.push(`Domain=${options.domain}`);
+    send(body, init) {
+        let { body: _body, type } = determineContentTypeBody(body);
+        const contentType = init?.headers?.["Content-Type"] ??
+            init?.headers?.["content-type"] ??
+            type;
+        return this.#newResponse(_body, contentType, init);
     }
-    if (options.secure) {
-        parts.push(`Secure`);
+    redirect(url, status = 302) {
+        const headers = new Headers(this.#headers);
+        headers.set("Location", url);
+        return new Response(null, { status, headers });
+    }
+    async download(filePath, filename) {
+        if (!(await fileExists(filePath)))
+            throw TezXError.notFound("File not found");
+        const buf = await 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,
+        });
     }
-    if (options.httpOnly) {
-        parts.push(`HttpOnly`);
+    async sendFile(filePath, init) {
+        if (!(await fileExists(filePath)))
+            throw TezXError.notFound("File not found");
+        let { size, mtime } = await fileSize(filePath);
+        const ext = extensionExtract(filePath);
+        const mimeType = mimeTypes[ext] ?? defaultMimeType;
+        let fileStream = await readStream(filePath);
+        let headers = {
+            "Content-Type": mimeType,
+            "Content-Length": size.toString(),
+            ...init?.headers,
+        };
+        let filename = init?.filename;
+        if (filename) {
+            headers["Content-Disposition"] = `attachment; filename="${filename}"`;
+        }
+        return this.newResponse(fileStream, {
+            status: init?.status ?? this.#status,
+            statusText: init?.statusText,
+            headers,
+        });
     }
-    if (options.sameSite) {
-        parts.push(`SameSite=${options.sameSite}`);
+    get args() {
+        return this.#args;
     }
-    return parts.join("; ");
 }

package/core/error.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Custom error type used throughout the Tezx application.
+ *
+ * Extends the built-in `Error` and carries an HTTP status code plus optional
+ * structured `details` payload (useful for validation errors, metadata, etc.).
+ *
+ * @example
+ * // Throw a 404
+ * throw TezXError.notFound("User not found", { userId });
+ *
+ * @example
+ * // Create and throw a custom status
+ * throw new TezXError("Something went wrong", 502);
+ *
+ * @class TezXError
+ * @extends Error
+ */
+export declare class TezXError extends Error {
+    /**
+     * HTTP status code representing the error (defaults to 500).
+     */
+    statusCode: number;
+    /**
+     * Optional additional details about the error (validation lists, meta, etc.).
+     */
+    details?: any;
+    /**
+     * Create an instance of TezXError.
+     *
+     * @param {string} message - Human readable error message.
+     * @param {number} [statusCode=500] - HTTP status code to associate with this error.
+     * @param {*} [details] - Optional additional error payload (e.g. validation errors).
+     */
+    constructor(message: string, statusCode?: number, details?: any);
+    /**
+     * Create a 400 Bad Request error.
+     *
+     * @param {string} [message="Bad Request"]
+     * @param {*} [details]
+     * @returns {TezXError}
+     */
+    static badRequest(message?: string, details?: any): TezXError;
+    /**
+     * Create a 401 Unauthorized error.
+     *
+     * @param {string} [message="Unauthorized"]
+     * @param {*} [details]
+     * @returns {TezXError}
+     */
+    static unauthorized(message?: string, details?: any): TezXError;
+    /**
+     * Create a 403 Forbidden error.
+     *
+     * @param {string} [message="Forbidden"]
+     * @param {*} [details]
+     * @returns {TezXError}
+     */
+    static forbidden(message?: string, details?: any): TezXError;
+    /**
+     * Create a 404 Not Found error.
+     *
+     * @param {string} [message="Resource Not Found"]
+     * @param {*} [details]
+     * @returns {TezXError}
+     */
+    static notFound(message?: string, details?: any): TezXError;
+    /**
+     * Create a 409 Conflict error.
+     *
+     * @param {string} [message="Conflict"]
+     * @param {*} [details]
+     * @returns {TezXError}
+     */
+    static conflict(message?: string, details?: any): TezXError;
+    /**
+     * Create a 500 Internal Server Error.
+     *
+     * @param {string} [message="Internal Server Error"]
+     * @param {*} [details]
+     * @returns {TezXError}
+     */
+    static internal(message?: string, details?: any): TezXError;
+    /**
+     * Convert the error into a JSON-serializable object that can be sent
+     * in HTTP responses or logged safely.
+     *
+     * @returns {{ error: boolean, message: string, statusCode: number, details: any }}
+     */
+    toJSON(): {
+        error: boolean;
+        message: string;
+        statusCode: number;
+        details: any;
+    };
+}
+export declare function TezXErrorParse(err: unknown, statusCode?: number): TezXError;

package/core/error.js

@@ -0,0 +1,44 @@
+export 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,
+        };
+    }
+}
+export function TezXErrorParse(err, statusCode) {
+    if (err instanceof TezXError)
+        return err;
+    else if (err instanceof Error)
+        return new TezXError(err?.message, 500, err?.stack);
+    return new TezXError(String(err), statusCode);
+}