tezx 3.0.14-beta → 3.0.14-beta2

package/utils/file.js

@@ -1,3 +1,4 @@
+import { TezXError } from "../core/error.js";
 import { runtime } from "./runtime.js";
 export async function fileExists(path) {
     switch (runtime) {
@@ -37,7 +38,7 @@ export async function getFileBuffer(path) {
         case "deno":
             return Deno.readFile(path);
         default:
-            throw new Error("Unsupported runtime environment");
+            throw new TezXError("Unsupported runtime environment");
     }
 }
 export async function readStream(path) {
@@ -54,22 +55,42 @@ export async function readStream(path) {
             return (await Deno.open(path, { read: true })).readable;
         }
         default:
-            throw new Error("Unsupported runtime environment");
+            throw new TezXError("Unsupported runtime environment");
     }
 }
 export async function fileSize(path) {
     switch (runtime) {
         case "node": {
             const { stat } = await import("node:fs/promises");
-            return (await stat(path)).size;
+            const st = await stat(path);
+            return { size: st.size, mtime: st.mtime };
         }
         case "bun": {
-            return Bun.file(path).size;
+            const st = await Bun.file(path).stat();
+            return { size: st.size, mtime: st.mtime };
         }
         case "deno": {
-            return (await Deno.stat(path)).size;
+            const st = await Deno.stat(path);
+            return {
+                size: st.size,
+                mtime: st.mtime ?? new Date(),
+            };
         }
         default:
-            return 0;
+            throw new TezXError("Unsupported runtime: " + runtime);
     }
 }
+export async function etagDigest(algo = "MD5", data) {
+    const encoded = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    if (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 import("node:crypto");
+    return createHash(algo).update(encoded).digest("hex");
+}

package/utils/generateID.d.ts

@@ -31,3 +31,12 @@ export declare function generateID(): string;
  * console.log(uuid); // "a63e47b6-6a3b-4d53-90b6-8db2f2d07943"
  */
 export declare function generateUUID(): string;
+/**
+ * Generate a short nonce (JS-only, low-GC) by sampling the BASE64 charset.
+ * This function intentionally uses Math.random for speed and low allocation.
+ * If you require cryptographic randomness, swap with crypto.randomFillSync.
+ *
+ * @param {number} [length=16] - nonce length in characters
+ * @returns {string} generated nonce string
+ */
+export declare function generateRandomBase64(length?: number): string;

package/utils/generateID.js

@@ -21,3 +21,12 @@ export function generateUUID() {
         return crypto.randomUUID();
     return generateID();
 }
+export function generateRandomBase64(length = 16) {
+    let result = "";
+    const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    for (let i = 0; i < length; i++) {
+        const idx = Math.floor(Math.random() * 64);
+        result += BASE64[idx];
+    }
+    return result;
+}

package/utils/response.js

@@ -9,7 +9,9 @@ export let notFoundResponse = (ctx) => {
 export async function handleErrorResponse(err = TezXError.internal(), ctx) {
     if (err instanceof TezXError) {
         GlobalConfig.debugging.error(err.details ?? err?.message);
-        return ctx.status(err.statusCode ?? 500).send(err.details ?? err?.message ?? "Internal Server Error");
+        return ctx
+            .status(err.statusCode ?? 500)
+            .send(err.details ?? err?.message ?? "Internal Server Error");
     }
     return await handleErrorResponse(TezXError.internal(), ctx);
 }

package/cjs/utils/regexRouter.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileRegexRoute = compileRegexRoute;
-exports.addBaseToRegex = addBaseToRegex;
-exports.regexMatchRoute = regexMatchRoute;
-const low_level_js_1 = require("./low-level.js");
-function compileRegexRoute(seg) {
-    const segments = typeof seg == "string" ? seg.split("/").filter(Boolean) : seg;
-    let regexStr = "^";
-    const paramNames = [];
-    for (let seg of segments) {
-        if (seg.startsWith(":")) {
-            const isOptional = seg.endsWith("?");
-            const name = seg.replace(":", "").replace("?", "");
-            paramNames.push(name);
-            regexStr += isOptional ? `(?:\\/([^\\/]+))?` : `\\/([^\\/]+)`;
-        }
-        else if (seg.startsWith("*")) {
-            const name = seg.slice(1) || "*";
-            paramNames.push(name);
-            regexStr += `\\/(.+)`;
-            break;
-        }
-        else {
-            regexStr += `\\/${seg}`;
-        }
-    }
-    regexStr += "\\/?$";
-    return {
-        regex: new RegExp(regexStr),
-        paramNames,
-    };
-}
-function addBaseToRegex(basePath, routeRegex) {
-    basePath = "/" + (0, low_level_js_1.sanitizePathSplitBasePath)("/", basePath)?.join("/");
-    if (basePath === "/")
-        basePath = "";
-    let body = routeRegex.source.replace(/^(\^)/, "").replace(/(\$)$/, "");
-    body = body.replace(/\\\//g, "/");
-    if (body.startsWith("/")) {
-        body = body.slice(1);
-    }
-    const cleaned = body.replace(/^\/+|\/+$/g, "").replace(/\/?\?$/, "");
-    const combined = basePath + "/" + cleaned + "/?";
-    const finalRegex = new RegExp(`^${combined}$`);
-    return finalRegex;
-}
-function regexMatchRoute(regex, url, paramNames = []) {
-    const match = url.match(regex);
-    if (!match)
-        return { success: false, params: {} };
-    const params = {};
-    paramNames.forEach((name, idx) => {
-        params[name] = match[idx + 1] ?? null;
-    });
-    return { params, success: true };
-}

package/utils/regexRouter.d.ts

@@ -1,66 +0,0 @@
-/**
- * Compiles a route string or segment array into a regular expression for matching URL paths.
- * Supports dynamic `:param`, optional `:param?`, and wildcard `*param` segments.
- *
- * @param {string | string[]} seg - The route pattern, either as a string (`'/user/:id'`)
- *   or an array of segments (`['user', ':id']`).
- *
- * @returns {{
- *   regex: RegExp,
- *   paramNames: string[]
- * }}
- * @example
- * const { regex, paramNames } = compileRegexRoute('/user/:id/post/:slug?');
- * // regex: /^\/user\/([^\/]+)\/(?:([^\/]+))?\/?$/
- * // paramNames: ['id', 'slug']
- *
- * regex.test('/user/123/post/hello'); // ✅ true
- * regex.test('/user/123/post');       // ✅ true (because :slug? is optional)
- *
- * @example
- * const { regex, paramNames } = compileRegexRoute('/files/*path');
- * // regex: /^\/files\/(.+)\/?$/
- * // paramNames: ['path']
- *
- * regex.test('/files/images/cat.jpg'); // ✅ true
- */
-export declare function compileRegexRoute(seg: string | string[]): {
-    regex: RegExp;
-    paramNames: string[];
-};
-/**
- * Combines a base path with a route regex pattern.
- *
- * @param basePath - The base path to prepend (e.g., '/api/v1')
- * @param routeRegex - The original route regex (e.g., /^\/users\/([^/]+?)$/)
- * @returns A new regex that includes the base path
- */
-export declare function addBaseToRegex(basePath: string, routeRegex: RegExp): RegExp;
-/**
- * Matches a given URL against a provided regular expression and extracts named parameters.
- *
- * @param {RegExp} regex - The regular expression to match against the URL.
- *   It should include capturing groups for each parameter.
- *   Example: /^\/user\/(\d+)\/post\/(\w+)$/
- *
- * @param {string} url - The URL string to match.
- *   Example: "/user/123/post/abc"
- *
- * @param {string[]} paramNames - An array of parameter names corresponding to the capturing groups in the regex.
- *   Example: ["userId", "postId"]
- *
- * @returns {{ success: boolean, params: Record<string, string | null> }} An object indicating:
- *   - `success`: whether the URL matched the regex.
- *   - `params`: an object mapping parameter names to their matched values, or `null` if not found.
- *
- * @example
- * const regex = /^\/user\/(\d+)\/post\/(\w+)$/;
- * const url = "/user/123/post/abc";
- * const paramNames = ["userId", "postId"];
- * const result = regexMatchRoute(regex, url, paramNames);
- * // result = { success: true, params: { userId: "123", postId: "abc" } }
- */
-export declare function regexMatchRoute(regex: RegExp, url: string, paramNames?: string[]): {
-    params: Record<string, string | null>;
-    success: boolean;
-};

package/utils/regexRouter.js

@@ -1,52 +0,0 @@
-import { sanitizePathSplitBasePath } from "./low-level.js";
-export function compileRegexRoute(seg) {
-    const segments = typeof seg == "string" ? seg.split("/").filter(Boolean) : seg;
-    let regexStr = "^";
-    const paramNames = [];
-    for (let seg of segments) {
-        if (seg.startsWith(":")) {
-            const isOptional = seg.endsWith("?");
-            const name = seg.replace(":", "").replace("?", "");
-            paramNames.push(name);
-            regexStr += isOptional ? `(?:\\/([^\\/]+))?` : `\\/([^\\/]+)`;
-        }
-        else if (seg.startsWith("*")) {
-            const name = seg.slice(1) || "*";
-            paramNames.push(name);
-            regexStr += `\\/(.+)`;
-            break;
-        }
-        else {
-            regexStr += `\\/${seg}`;
-        }
-    }
-    regexStr += "\\/?$";
-    return {
-        regex: new RegExp(regexStr),
-        paramNames,
-    };
-}
-export function addBaseToRegex(basePath, routeRegex) {
-    basePath = "/" + sanitizePathSplitBasePath("/", basePath)?.join("/");
-    if (basePath === "/")
-        basePath = "";
-    let body = routeRegex.source.replace(/^(\^)/, "").replace(/(\$)$/, "");
-    body = body.replace(/\\\//g, "/");
-    if (body.startsWith("/")) {
-        body = body.slice(1);
-    }
-    const cleaned = body.replace(/^\/+|\/+$/g, "").replace(/\/?\?$/, "");
-    const combined = basePath + "/" + cleaned + "/?";
-    const finalRegex = new RegExp(`^${combined}$`);
-    return finalRegex;
-}
-export function regexMatchRoute(regex, url, paramNames = []) {
-    const match = url.match(regex);
-    if (!match)
-        return { success: false, params: {} };
-    const params = {};
-    paramNames.forEach((name, idx) => {
-        params[name] = match[idx + 1] ?? null;
-    });
-    return { params, success: true };
-}