tezx 2.0.11 → 3.0.0

package/middleware/i18n.js

@@ -1,75 +1,88 @@
-import { GlobalConfig } from "../core/config.js";
-export const i18n = (options) => {
-    const { loadTranslations, defaultCacheDuration = 3600000, isCacheValid = (cached) => cached.expiresAt > Date.now(), detectLanguage = (ctx) => ctx.req.query.lang ||
-        ctx.cookies?.get("lang") ||
-        ctx.req.headers.get("accept-language")?.split(",")[0] ||
-        options.defaultLanguage ||
-        "en", defaultLanguage = "en", fallbackChain = [], translationFunctionKey = "t", formatMessage = (message, options = {}) => {
-        return Object.entries(options).reduce((msg, [key, value]) => msg.replace(new RegExp(`{{${key}}}`, "g"), String(value)), message);
-    }, cacheTranslations = true, } = options;
-    const translationCache = {};
+import { TezXError } from "../index.js";
+const i18n = (options) => {
+    const { loadTranslations, defaultCacheDuration = 3600000, detectLanguage, defaultLanguage = "en", translationFunctionKey = "t", formatMessage = (msg, vars = {}) => {
+        if (vars && msg.indexOf("{{") !== -1) {
+            let out = "";
+            let i = 0;
+            while (i < msg.length) {
+                const startVar = msg.indexOf("{{", i);
+                if (startVar === -1) {
+                    out += msg.slice(i);
+                    break;
+                }
+                const endVar = msg.indexOf("}}", startVar + 2);
+                if (endVar === -1) {
+                    out += msg.slice(i);
+                    break;
+                }
+                out += msg.slice(i, startVar);
+                const keyVar = msg.slice(startVar + 2, endVar).trim();
+                out += vars[keyVar] !== undefined ? String(vars[keyVar]) : "";
+                i = endVar + 2;
+            }
+            return out;
+        }
+        return msg;
+    }, isCacheValid = (cached) => cached.expiresAt > Date.now(), cacheTranslations = false, cacheStorage: externalCache = null, } = options;
+    let localCache = null;
+    if (cacheTranslations && !externalCache)
+        localCache = new Map();
     return async function i18n(ctx, next) {
         try {
-            const detectedLanguage = detectLanguage(ctx);
-            const languageChain = [
-                detectedLanguage,
-                ...fallbackChain,
-                defaultLanguage,
-            ].filter(Boolean);
-            let translations = null;
-            let selectedLanguage = defaultLanguage;
-            for (const lang of languageChain) {
-                const normalizedLang = lang.split("-")[0].toLowerCase();
-                if (cacheTranslations && translationCache[normalizedLang]) {
-                    const cached = translationCache[normalizedLang];
-                    if (isCacheValid(cached, normalizedLang)) {
+            const lang = detectLanguage(ctx) ?? defaultLanguage;
+            let translations = undefined;
+            if (cacheTranslations) {
+                if (externalCache) {
+                    const cached = await externalCache.get(lang);
+                    if (cached && isCacheValid(cached, lang))
                         translations = cached.translations;
-                        selectedLanguage = lang;
-                        break;
-                    }
-                    delete translationCache[normalizedLang];
-                }
-                try {
-                    const { translations: loadedTranslations, expiresAt } = await loadTranslations(normalizedLang);
-                    let expirationTime = Date.now() + defaultCacheDuration;
-                    if (expiresAt instanceof Date) {
-                        expirationTime = expiresAt.getTime();
-                    }
-                    else if (typeof expiresAt === "number") {
-                        expirationTime = expiresAt;
-                    }
-                    translations = loadedTranslations;
-                    selectedLanguage = lang;
-                    if (cacheTranslations) {
-                        translationCache[normalizedLang] = {
-                            translations,
-                            expiresAt: expirationTime,
-                        };
-                    }
-                    break;
                 }
-                catch (error) {
-                    GlobalConfig.debugging.warn(`Translation load failed for ${lang}:`, error);
+                else if (localCache?.get(lang)) {
+                    const cached = localCache.get(lang);
+                    if (isCacheValid(cached, lang))
+                        translations = cached.translations;
+                    else
+                        localCache.delete(lang);
                 }
             }
             if (!translations) {
-                throw new Error("No translations available");
+                translations = await loadTranslations(lang);
+                const expiresAt = Date.now() + defaultCacheDuration;
+                if (cacheTranslations) {
+                    if (externalCache) {
+                        await externalCache.set(lang, { translations, expiresAt });
+                    }
+                    else {
+                        localCache?.set(lang, { translations, expiresAt });
+                    }
+                }
             }
-            ctx[translationFunctionKey] = (key, options) => {
-                const value = key.split(".").reduce((acc, k) => {
-                    return acc && typeof acc === "object" ? acc[k] : undefined;
-                }, translations);
-                const message = typeof value === "string" ? value : key;
-                return formatMessage(message, options);
+            ctx[translationFunctionKey] = function translate(key, vars) {
+                let acc = translations;
+                let start = 0;
+                for (let i = 0; i <= key.length; i++) {
+                    const c = key.charCodeAt(i);
+                    if (c === 46 || i === key.length) {
+                        const segment = key.slice(start, i);
+                        if (acc && typeof acc === "object") {
+                            acc = acc[segment];
+                        }
+                        else {
+                            acc = undefined;
+                            break;
+                        }
+                        start = i + 1;
+                    }
+                }
+                let msg = typeof acc === "string" ? acc : key;
+                return formatMessage(msg, vars);
             };
-            ctx.language = selectedLanguage;
-            ctx.languageChain = languageChain;
+            ctx.language = lang;
             return await next();
         }
         catch (error) {
-            GlobalConfig.debugging.error("i18n processing error:", error);
-            ctx.setStatus = 500;
-            throw error;
+            throw new TezXError(error?.message ?? "i18n failed", 500, error?.stack);
         }
     };
 };
+export { i18n as default, i18n };

package/middleware/index.d.ts

@@ -1,38 +1,14 @@
-import { cors } from "./cors.js";
-import { logger } from "./logger.js";
-export * from "./basicAuth.js";
-export * from "./cacheControl.js";
+export * from "./basic-auth.js";
+export * from "./bearer-auth.js";
+export * from "./cache-control.js";
 export * from "./cors.js";
-export { detectBot } from "./detectBot.js";
-export type { DetectBotReason } from "./detectBot.js";
-export * from "./detectLocale.js";
+export * from "./detect-bot.js";
 export * from "./i18n.js";
-export * from "./lazyLoadModules.js";
 export * from "./logger.js";
 export * from "./pagination.js";
 export * from "./powered-by.js";
-export * from "./rateLimiter.js";
+export * from "./rate-limiter.js";
 export * from "./request-id.js";
-export * from "./requestTimeout.js";
-export * from "./sanitizeHeader.js";
-export * from "./secureHeaders.js";
-export * from "./xssProtection.js";
-declare const _default: {
-    basicAuth: (options: import("./basicAuth.js").DynamicBasicAuthOptions) => import("../index.js").Middleware;
-    cacheControl: (options: import("./cacheControl.js").CacheOptions) => import("../index.js").Middleware;
-    cors: typeof cors;
-    detectBot: (options?: import("./detectBot.js").DetectBotOptions) => import("../index.js").Middleware;
-    detectLocale: (options: import("./detectLocale.js").DetectLocaleOptions) => import("../index.js").Middleware;
-    i18n: (options: import("./i18n.js").I18nOptions) => import("../index.js").Middleware;
-    lazyLoadModules: <T = any>(options: import("./lazyLoadModules.js").LazyLoadOptions<T>) => import("../index.js").Middleware;
-    logger: typeof logger;
-    paginationHandler: (options?: import("./pagination.js").PaginationOptions) => import("../index.js").Middleware;
-    poweredBy: (serverName?: string) => import("../index.js").Middleware;
-    rateLimiter: (options: import("./rateLimiter.js").RateLimiterOptions) => import("../index.js").Middleware;
-    requestID: (headerName?: string, contextKey?: string) => import("../index.js").Middleware;
-    requestTimeout: (options: import("./requestTimeout.js").TimeoutOptions) => import("../index.js").Middleware;
-    sanitizeHeaders: (options?: import("./sanitizeHeader.js").SanitizeHeadersOptions) => import("../index.js").Middleware;
-    secureHeaders: (options?: import("./secureHeaders.js").SecurityHeaderOptions) => import("../index.js").Middleware;
-    xssProtection: (options?: import("./xssProtection.js").XSSProtectionOptions) => (ctx: import("../index.js").BaseContext, next: import("../index.js").NextCallback) => Promise<any>;
-};
-export default _default;
+export * from "./sanitize-headers.js";
+export * from "./secure-headers.js";
+export * from "./xss-protection.js";

package/middleware/index.js

@@ -1,50 +1,14 @@
-import { basicAuth } from "./basicAuth.js";
-import { cacheControl } from "./cacheControl.js";
-import { cors } from "./cors.js";
-import { detectBot } from "./detectBot.js";
-import { detectLocale } from "./detectLocale.js";
-import { i18n } from "./i18n.js";
-import { lazyLoadModules } from "./lazyLoadModules.js";
-import { logger } from "./logger.js";
-import { paginationHandler } from "./pagination.js";
-import { poweredBy } from "./powered-by.js";
-import { rateLimiter } from "./rateLimiter.js";
-import { requestID } from "./request-id.js";
-import { requestTimeout } from "./requestTimeout.js";
-import { sanitizeHeaders } from "./sanitizeHeader.js";
-import { secureHeaders } from "./secureHeaders.js";
-import { xssProtection } from "./xssProtection.js";
-export * from "./basicAuth.js";
-export * from "./cacheControl.js";
+export * from "./basic-auth.js";
+export * from "./bearer-auth.js";
+export * from "./cache-control.js";
 export * from "./cors.js";
-export { detectBot } from "./detectBot.js";
-export * from "./detectLocale.js";
+export * from "./detect-bot.js";
 export * from "./i18n.js";
-export * from "./lazyLoadModules.js";
 export * from "./logger.js";
 export * from "./pagination.js";
 export * from "./powered-by.js";
-export * from "./rateLimiter.js";
+export * from "./rate-limiter.js";
 export * from "./request-id.js";
-export * from "./requestTimeout.js";
-export * from "./sanitizeHeader.js";
-export * from "./secureHeaders.js";
-export * from "./xssProtection.js";
-export default {
-    basicAuth,
-    cacheControl,
-    cors,
-    detectBot,
-    detectLocale,
-    i18n,
-    lazyLoadModules,
-    logger,
-    paginationHandler,
-    poweredBy,
-    rateLimiter,
-    requestID,
-    requestTimeout,
-    sanitizeHeaders,
-    secureHeaders,
-    xssProtection,
-};
+export * from "./sanitize-headers.js";
+export * from "./secure-headers.js";
+export * from "./xss-protection.js";

package/middleware/logger.d.ts

@@ -7,9 +7,12 @@ import { Middleware } from "../types/index.js";
  *
  * @example
  * ```ts
- * import { logger } from 'tezx';
+ * import { logger } from 'tezx/logger';
  *
  * app.use(logger());
  * ```
  */
-export declare function logger(): Middleware;
+declare function logger(options?: {
+    enabled: boolean;
+}): Middleware;
+export { logger as default, logger };

package/middleware/logger.js

@@ -1,18 +1,23 @@
+import { TezXError } from "../core/error.js";
 import { colorText } from "../utils/colors.js";
-export function logger() {
+function logger(options = { enabled: true }) {
     return async function logger(ctx, next) {
         try {
+            if (!options?.enabled) {
+                return next();
+            }
             console.log(`${colorText("<--", "bold")} ${colorText(ctx.method, "bgMagenta")} ${ctx.pathname}`);
             const startTime = performance.now();
-            let n = await next();
+            let n = (await next());
             const elapsed = performance.now() - startTime;
             console.log(`${colorText("-->", "bold")} ${colorText(ctx.method, "bgBlue")} ${ctx.pathname} ` +
-                `${colorText(ctx.getStatus, "yellow")} ${colorText(`${elapsed.toFixed(2)}ms`, "magenta")}`);
+                `${colorText(n ? ctx.getStatus : 404, "yellow")} ${colorText(`${elapsed.toFixed(2)}ms`, "magenta")}`);
             return n;
         }
         catch (err) {
             console.error(`${colorText("Error:", "red")}`, err.stack);
-            throw new Error(err.stack);
+            throw new TezXError(err.stack);
         }
     };
 }
+export { logger as default, logger };

package/middleware/pagination.d.ts

@@ -1,5 +1,5 @@
-import { Context, Middleware } from "../index.js";
-export type PaginationOptions = {
+import { Context } from "../index.js";
+export type PaginationOptions<DataKey extends string = "data", CountKey extends string = "total", Item = any> = {
     /**
      * 🔢 Default page number when not specified
      * @default 1
@@ -35,13 +35,13 @@ export type PaginationOptions = {
      * @default "total"
      * @example "totalCount" // Read from response.totalCount
      */
-    countKey?: string;
+    countKey?: CountKey;
     /**
      * 📦 Key containing the data array in response
      * @default "data"
      * @example "items" // Process response.items array
      */
-    dataKey?: string;
+    dataKey?: DataKey;
     /**
      * 🛠️ Function to fetch data dynamically
      * @param ctx - Request context
@@ -57,7 +57,9 @@ export type PaginationOptions = {
         limit: number;
         offset: number;
     }) => Promise<{
-        [key: string]: any;
+        [K in DataKey]: Item[];
+    } & {
+        [K in CountKey]: number;
     }>;
 };
 export type PaginationBodyType = {
@@ -100,4 +102,5 @@ export type PaginationBodyType = {
  *   }
  * }));
  */
-export declare const paginationHandler: (options?: PaginationOptions) => Middleware;
+declare const paginationHandler: <DataKey extends string = "data", CountKey extends string = "total", Item = any>(options?: PaginationOptions<DataKey, CountKey, Item>) => any;
+export { paginationHandler, paginationHandler as default };

package/middleware/pagination.js

@@ -1,5 +1,5 @@
-export const paginationHandler = (options = {}) => {
-    const { defaultPage = 1, defaultLimit = 10, maxLimit = 100, queryKeyPage = "page", queryKeyLimit = "limit", countKey = "total", dataKey = "data", getDataSource, } = options;
+const paginationHandler = (options = {}) => {
+    let { defaultPage = 1, defaultLimit = 10, maxLimit = 100, queryKeyPage = "page", queryKeyLimit = "limit", countKey = "total", dataKey = "data", getDataSource, } = options;
     return async function paginationHandler(ctx, next) {
         const rawPage = ctx.req.query[queryKeyPage];
         const rawLimit = ctx.req.query[queryKeyLimit];
@@ -47,3 +47,4 @@ export const paginationHandler = (options = {}) => {
         return await next();
     };
 };
+export { paginationHandler, paginationHandler as default };

package/middleware/powered-by.d.ts

@@ -13,4 +13,5 @@ import { Middleware } from "../types/index.js";
  * app.use(poweredBy("MyServer"));
  * ```
  */
-export declare const poweredBy: (serverName?: string) => Middleware;
+declare const poweredBy: (serverName?: string) => Middleware;
+export { poweredBy, poweredBy as default };

package/middleware/powered-by.js

@@ -1,6 +1,7 @@
-export const poweredBy = (serverName) => {
+const poweredBy = (serverName) => {
     return function poweredBy(ctx, next) {
-        ctx.header("X-Powered-By", serverName || "TezX");
+        ctx.headers.set("x-powered-by", serverName || "TezX");
         return next();
     };
 };
+export { poweredBy, poweredBy as default };

package/middleware/{rateLimiter.d.ts → rate-limiter.d.ts}

@@ -1,5 +1,6 @@
 import { Context } from "../core/context.js";
-import { CallbackReturn, Middleware } from "../types/index.js";
+import { TezXError } from "../core/error.js";
+import { HttpBaseResponse, Middleware } from "../types/index.js";
 export type RateLimiterOptions = {
     /**
      * 🔴 Maximum allowed requests in the time window
@@ -20,10 +21,6 @@ export type RateLimiterOptions = {
      * keyGenerator: (ctx) => ctx.user?.id || ctx.ip // Use user ID if authenticated
      */
     keyGenerator?: (ctx: Context) => string;
-    /**
-      //  * ⚠️ (Future) Storage backend - currently memory only
-      //  * @todo Implement Redis storage
-      //  */
     /**
      * 🔄 Custom cache storage implementation (e.g., using `Map`, `Redis`, etc.).
      * By default, it uses a `Map<string, { count: number; resetTime: number }>`.
@@ -45,17 +42,25 @@ export type RateLimiterOptions = {
      * @example
      * onError: (ctx, retryAfter) => {
      *   ctx.status = 429;
-     *   throw new Error( `Rate limit exceeded. Try again in ${retryAfter} seconds.`);
+     *   throw new TezXError( `Rate limit exceeded. Try again in ${retryAfter} seconds.`);
      * }
      */
-    onError?: (ctx: Context, retryAfter: number, error: Error) => CallbackReturn;
+    onError?: (ctx: Context, retryAfter: number, error: TezXError) => HttpBaseResponse;
 };
 /**
  * 🚦 Rate limiting middleware for request throttling
  *
  * Enforces maximum request limits per client with sliding window.
  * Currently supports in-memory storage only (Redis coming soon).
- *
+ * @requires
+ *  *
+```ts
+  import { getConnInfo } from "tezx/bun";
+  // or
+  import { getConnInfo } from "tezx/deno";
+  // or
+  import { getConnInfo } from "tezx/node";
+```
  * @param {RateLimiterOptions} options - Configuration
  * @returns {Middleware} Middleware function
  *
@@ -73,4 +78,5 @@ export type RateLimiterOptions = {
  *   keyGenerator: (ctx) => ctx.user?.id || ctx.ip
  * }));
  */
-export declare const rateLimiter: (options: RateLimiterOptions) => Middleware;
+declare const rateLimiter: (options: RateLimiterOptions) => Middleware;
+export { rateLimiter, rateLimiter as default };

package/middleware/rate-limiter.js

@@ -0,0 +1,34 @@
+import { TezXError } from "../core/error.js";
+import { createRateLimitDefaultStorage, isRateLimit, } from "../utils/rateLimit.js";
+const rateLimiter = (options) => {
+    const { maxRequests, windowMs, keyGenerator = (ctx) => {
+        const xForwardedFor = ctx.req.header("x-forwarded-for");
+        if (xForwardedFor) {
+            const ip = xForwardedFor.split(",")[0].trim();
+            return ip;
+        }
+        const clientIp = ctx.req.header("client-ip");
+        if (clientIp)
+            return clientIp;
+        const addr = ctx.req.remoteAddress?.address || "unknown";
+        const port = ctx.req.remoteAddress?.port || "0";
+        return `${addr}:${port}`;
+    }, storage = createRateLimitDefaultStorage(), onError = (ctx, retryAfter, error) => {
+        ctx.setStatus = 429;
+        throw new TezXError(`Rate limit exceeded. Try again in ${retryAfter} seconds.`, 429);
+    }, } = options;
+    return async function rateLimiter(ctx, next) {
+        const key = keyGenerator(ctx);
+        const { check, entry } = isRateLimit(key, storage, maxRequests, windowMs);
+        if (check) {
+            const retryAfter = Math.ceil((entry.resetTime - Date.now()) / 1000);
+            ctx.headers.set("Retry-After", retryAfter.toString());
+            return onError(ctx, retryAfter, new TezXError(`Rate limit exceeded. Retry after ${retryAfter} seconds.`));
+        }
+        ctx.headers.set("X-RateLimit-Limit", maxRequests.toString());
+        ctx.headers.set("X-RateLimit-Remaining", (maxRequests - entry.count).toString());
+        ctx.headers.set("X-RateLimit-Reset", entry.resetTime.toString());
+        return await next();
+    };
+};
+export { rateLimiter, rateLimiter as default };

package/middleware/request-id.d.ts

@@ -13,4 +13,5 @@ import { Middleware } from "../types/index.js";
  * app.use(requestID());
  * ```
  */
-export declare const requestID: (headerName?: string, contextKey?: string) => Middleware;
+declare const requestID: (headerName?: string, contextKey?: string) => Middleware;
+export { requestID as default, requestID };

package/middleware/request-id.js

@@ -1,11 +1,10 @@
-import { generateID } from "../helper/index.js";
-export const requestID = (headerName = "X-Request-ID", contextKey = "requestID") => {
+import { generateUUID } from "../helper/index.js";
+const requestID = (headerName = "X-Request-ID", contextKey = "requestID") => {
     return function requestID(ctx, next) {
-        const existingID = ctx.headers?.get(headerName.toLowerCase()) ||
-            ctx.headers?.get(headerName);
-        const requestId = existingID || `req-${generateID()}`;
+        let requestId = ctx.headers.get(headerName) ?? `req-${generateUUID()}`;
         ctx[contextKey] = requestId;
-        ctx.header(headerName, requestId);
+        ctx.headers.set(headerName, requestId);
         return next();
     };
 };
+export { requestID as default, requestID };

package/middleware/{sanitizeHeader.d.ts → sanitize-headers.d.ts}

@@ -1,4 +1,4 @@
-import { Middleware } from "../types/index.js";
+import { Middleware, ResHeaderKey } from "../types/index.js";
 export type SanitizeHeadersOptions = {
     /**
      * 🟢 Whitelist of allowed headers (case-insensitive)
@@ -6,29 +6,14 @@ export type SanitizeHeadersOptions = {
      * @example
      * whitelist: ['content-type', 'authorization'] // Only allow these headers
      */
-    whitelist?: string[];
+    whitelist?: ResHeaderKey[];
     /**
      * 🔴 Blacklist of disallowed headers (case-insensitive)
      * @default [] (block none if empty)
      * @example
      * blacklist: ['x-powered-by', 'server'] // Block server info headers
      */
-    blacklist?: string[];
-    /**
-     * 🔵 Normalize header keys to lowercase
-     * @default true
-     * @example
-     * normalizeKeys: false // Preserve original header case
-     */
-    normalizeKeys?: boolean;
-    /**
-     * 🟠 Allow potentially unsafe characters in header values
-     * @default false
-     * @warning Enabling this may reduce security
-     * @example
-     * allowUnsafeCharacters: true // Allow CR/LF in headers
-     */
-    allowUnsafeCharacters?: boolean;
+    blacklist?: ResHeaderKey[];
 };
 /**
  * 🧼 Middleware to sanitize HTTP headers for security and compliance
@@ -49,4 +34,5 @@ export type SanitizeHeadersOptions = {
  *   normalizeKeys: true
  * }));
  */
-export declare const sanitizeHeaders: (options?: SanitizeHeadersOptions) => Middleware;
+declare const sanitizeHeaders: (options?: SanitizeHeadersOptions) => Middleware;
+export { sanitizeHeaders as default, sanitizeHeaders };

package/middleware/sanitize-headers.js

@@ -0,0 +1,18 @@
+const sanitizeHeaders = (options = {}) => {
+    const { whitelist = [], blacklist = [] } = options;
+    const normalizedWhitelist = whitelist.map((h) => h.toLowerCase());
+    const normalizedBlacklist = blacklist.map((h) => h.toLowerCase());
+    let lWhite = normalizedWhitelist.length;
+    return async function sanitizeHeaders(ctx, next) {
+        await next();
+        for (const key of ctx.headers.keys()) {
+            if (lWhite > 0 && !normalizedWhitelist.includes(key)) {
+                ctx.headers.delete(key);
+            }
+            if (normalizedBlacklist.includes(key)) {
+                ctx.headers.delete(key);
+            }
+        }
+    };
+};
+export { sanitizeHeaders as default, sanitizeHeaders };

package/middleware/secure-headers copy.d.ts

@@ -0,0 +1,15 @@
+export type SecureHeadersOptions = {
+    preset?: "strict" | "balanced" | "dev";
+    hsts?: boolean;
+    hstsMaxAge?: number;
+    frameGuard?: "DENY" | "SAMEORIGIN" | string;
+    noSniff?: boolean;
+    xssProtection?: boolean;
+    referrerPolicy?: string;
+    permissionsPolicy?: string;
+    csp?: string | Record<string, string | string[]>;
+    cspReportOnly?: boolean;
+    cspUseNonce?: boolean;
+    ultraFastMode?: boolean;
+};
+export declare const secureHeaders: <T extends Record<string, any> = {}, Path extends string = any>(userOpts?: SecureHeadersOptions) => (ctx: any, next: () => Promise<any>) => Promise<any>;