tezx 3.0.9-beta → 3.0.11-beta

package/middleware/i18n.d.ts

@@ -1,102 +0,0 @@
-import { Context, Middleware } from "../index.js";
-export type TranslationMap = {
-    [key: string]: string | TranslationMap;
-};
-export type loadTranslations = (language: string) => Promise<{
-    translations: TranslationMap;
-    expiresAt?: Date | number;
-}>;
-export type I18nOptions = {
-    /**
-     * 🌐 Function to load translations dynamically
-     * @param language - Language code to load (e.g., "en-US")
-     * @returns Promise with translations map and optional expiration
-     */
-    loadTranslations: (language: string) => Promise<{
-        translations: TranslationMap;
-        expiresAt?: Date | number;
-    }>;
-    /**
-     * ⏱️ Default cache duration in milliseconds
-     * @default 3600000 (1 hour)
-     */
-    defaultCacheDuration?: number;
-    /**
-     * 🔄 Function to check if cached translations are stale
-     * @default Checks expiration time
-     * @example
-     * isCacheValid: (cached, lang) => {
-     *   return cached.expiresAt > Date.now() &&
-     *          cached.version === getCurrentVersion(lang);
-     * }
-     */
-    isCacheValid?: (cached: {
-        translations: TranslationMap;
-        expiresAt: number;
-    }, language: string) => boolean;
-    /**
-     * 🔍 Custom language detection function
-     * @default Checks query param → cookie → Accept-Language header → default
-     * @example
-     * detectLanguage: (ctx) => ctx.cookies.get('user_lang') || 'en'
-     */
-    detectLanguage?: (ctx: Context) => string;
-    /**
-     * 🏠 Default fallback language
-     * @default "en"
-     */
-    defaultLanguage?: string;
-    /**
-     * 🔀 Language fallback chain (most specific to least)
-     * @example ["fr-CA", "fr", "en"] // Try Canadian French → French → English
-     */
-    fallbackChain?: string[];
-    /**
-     * 🗝️ Context property name for translation function
-     * @default "t"
-     */
-    translationFunctionKey?: string;
-    /**
-     * 💬 Message formatting function
-     * @default Basic template replacement ({{key}})
-     * @example
-     * formatMessage: (msg, vars) => {
-     *   return msg.replace(/\{(\w+)\}/g, (_, k) => vars[k]);
-     * }
-     */
-    formatMessage?: (message: string, options?: Record<string, any>) => string;
-    /**
-     * 🗃️ Cache loaded translations
-     * @default true
-     */
-    cacheTranslations?: boolean;
-};
-/**
- * 🌍 Advanced i18n middleware with dynamic loading and fallback support
- *
- * Features:
- * - Hierarchical language resolution
- * - Nested translation keys
- * - Template interpolation
- * - Optional caching
- * - Custom language detection
- *
- * @param {I18nOptions} options - Configuration options
- * @returns {Middleware} Configured middleware
- *
- * @example
- * // Basic usage
- * app.use(i18n({
- *   loadTranslations: lang => import(`./locales/${lang}.json`),
- *   defaultLanguage: 'en'
- * }));
- *
- * // With caching and custom detection
- * app.use(i18n({
- *   loadTranslations: fetchTranslations,
- *   detectLanguage: ctx => ctx.get('X-Language'),
- *   cacheTranslations: true
- * }));
- */
-declare const i18n: (options: I18nOptions) => Middleware;
-export { i18n, i18n as default };

package/middleware/i18n.js

@@ -1,89 +0,0 @@
-import { GlobalConfig } from "../core/config.js";
-import { getCookie } from "../utils/cookie.js";
-const i18n = (options) => {
-    const { loadTranslations, defaultCacheDuration = 3600000, isCacheValid = (cached) => cached.expiresAt > Date.now(), detectLanguage = (ctx) => {
-        if (ctx.req.query.lang) {
-            return ctx.req.query.lang;
-        }
-        else if (getCookie(ctx, "lang")) {
-            return ctx.cookies?.["lang"];
-        }
-        else if (ctx.req.header("accept-language")) {
-            const lang = ctx.req.header("accept-language")?.split(",")[0];
-            if (lang)
-                return lang;
-        }
-        else if (options.defaultLanguage) {
-            return options.defaultLanguage;
-        }
-        return "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 = {};
-    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)) {
-                        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);
-                }
-            }
-            if (!translations) {
-                throw new Error("No translations available");
-            }
-            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.language = selectedLanguage;
-            ctx.languageChain = languageChain;
-            return await next();
-        }
-        catch (error) {
-            GlobalConfig.debugging.error("i18n processing error:", error);
-            ctx.setStatus = 500;
-            throw error;
-        }
-    };
-};
-export { i18n, i18n as default };

package/middleware/lazy-loader.d.ts

@@ -1,73 +0,0 @@
-import { Context, Middleware } from "../index.js";
-export type LazyModuleLoader<T> = () => Promise<T>;
-export interface CacheItem<T = any> {
-    module: T;
-    expiresAt: number;
-}
-export interface LazyLoadOptions<T> {
-    /**
-     * 🗺️ Key to identify the module to load. This can be a function that extracts the module name from the request context.
-     * @default (ctx) => ctx.req.params[queryKeyModule] || ctx.req.query[queryKeyModule]
-     */
-    moduleKey?: (ctx: Context) => string;
-    /**
-     * 🛠️ Function that returns a loader function for the specified module, used to dynamically load the module.
-     * If this function returns null, it indicates no loader is available for the module.
-     */
-    getModuleLoader: (ctx: Context) => Promise<LazyModuleLoader<T> | null> | null | LazyModuleLoader<T>;
-    /**
-     * 🔍 Query parameter name to select which module to load (e.g., "module").
-     * @default "module"
-     */
-    queryKeyModule?: string;
-    /**
-     * 📦 Key to attach the loaded module to the context object.
-     * @default "module"
-     */
-    moduleContextKey?: string;
-    /**
-     * 🔄 Enable caching of loaded modules to avoid re-loading them repeatedly.
-     * @default true
-     */
-    enableCache?: boolean;
-    /**
-     * 🔄 Custom cache storage implementation (e.g., using `Map`, `Redis`, etc.).
-     * By default, it uses a `Map<string, CacheItem<T>>`.
-     */
-    cacheStorage?: {
-        get: (key: string) => CacheItem<T> | undefined;
-        set: (key: string, value: CacheItem<T>) => void;
-        delete: (key: string) => void;
-    };
-    /**
-     * ⏳ Cache Time-To-Live (TTL) in milliseconds. This determines how long cached modules are valid.
-     * @default 3600000 (1 hour)
-     */
-    cacheTTL?: number;
-    /**
-     * 🌟 Lifecycle hooks for the module loading process.
-     * These hooks allow for custom actions at various stages of loading the module (e.g., when a module is loaded or when cache is hit).
-     */
-    lifecycleHooks?: {
-        onLoad?: (moduleName: string, ctx: Context) => void;
-        onError?: (moduleName: string, error: Error, ctx: Context) => void;
-        onComplete?: (moduleName: string, module: T, ctx: Context) => void;
-        onCacheHit?: (moduleName: string, module: T, ctx: Context) => void;
-        onCacheSet?: (moduleName: string, module: T, ctx: Context) => void;
-    };
-    /**
-     * 🛡️ Module validation function to ensure the module meets specific criteria before use.
-     * This function will be called after the module is loaded to verify its structure or behavior.
-     * If validation fails, an error is thrown.
-     */
-    validateModule?: (module: T) => boolean;
-}
-/**
- * Middleware for handling lazy loading of modules. This middleware allows dynamically loading modules based on route or query parameters.
- * It supports caching, lifecycle hooks, and module validation.
- *
- * @param options - Custom options for lazy loading, including caching, hooks, and module validation.
- * @returns A middleware function to use in your application.
- */
-declare const lazyLoader: <T = any>(options: LazyLoadOptions<T>) => Middleware;
-export { lazyLoader, lazyLoader as default };

package/middleware/lazy-loader.js

@@ -1,70 +0,0 @@
-import { GlobalConfig } from "../core/config.js";
-const lazyLoader = (options) => {
-    const { moduleKey = (ctx) => ctx.req.params[queryKeyModule] || ctx.req.query[queryKeyModule], getModuleLoader, queryKeyModule = "module", moduleContextKey = "module", cacheTTL = 3600000, enableCache = true, cacheStorage, lifecycleHooks = {}, validateModule, } = options;
-    let storage = cacheStorage;
-    if (enableCache && !cacheStorage) {
-        storage = new Map();
-    }
-    return async function lazyLoader(ctx, next) {
-        let moduleName = moduleKey(ctx) ||
-            ctx.req.params[queryKeyModule] ||
-            ctx.req.query[queryKeyModule];
-        if (!moduleName) {
-            GlobalConfig.debugging.warn("No module specified for lazy loading.");
-            return await next();
-        }
-        try {
-            if (enableCache) {
-                const cached = storage.get(moduleName);
-                if (cached) {
-                    if (cached.expiresAt < Date.now()) {
-                        storage.delete(moduleName);
-                    }
-                    else {
-                        GlobalConfig.debugging.info(`Using cached module: ${moduleName}`);
-                        ctx[moduleContextKey] = cached?.module;
-                        lifecycleHooks.onCacheHit?.(moduleName, ctx[moduleContextKey], ctx);
-                        lifecycleHooks.onComplete?.(moduleName, ctx[moduleContextKey], ctx);
-                        return await next();
-                    }
-                }
-            }
-            if (!getModuleLoader) {
-                throw new Error(`No module loader found for module: ${moduleName}`);
-            }
-            const moduleLoader = await getModuleLoader(ctx);
-            if (!moduleLoader) {
-                throw new Error(`No loader found for module: ${moduleName}`);
-            }
-            lifecycleHooks.onLoad?.(moduleName, ctx);
-            const module = await moduleLoader();
-            if (validateModule && !validateModule(module)) {
-                throw new Error(`Module validation failed for: ${moduleName}`);
-            }
-            if (enableCache) {
-                storage.set(moduleName, {
-                    module,
-                    expiresAt: Date.now() + cacheTTL,
-                });
-                lifecycleHooks.onCacheSet?.(moduleName, module, ctx);
-            }
-            ctx[moduleContextKey] = module;
-            if (module.init && typeof module.init === "function") {
-                const initResult = await module.init(ctx);
-                if (initResult) {
-                    return initResult;
-                }
-            }
-            lifecycleHooks.onComplete?.(moduleName, module, ctx);
-            GlobalConfig.debugging.success(`Successfully loaded module: ${moduleName}`);
-        }
-        catch (error) {
-            GlobalConfig.debugging.error(`Error loading module: ${moduleName}`, error);
-            lifecycleHooks.onError?.(moduleName, error, ctx);
-            ctx.setStatus = 500;
-            throw error;
-        }
-        return await next();
-    };
-};
-export { lazyLoader, lazyLoader as default };

package/middleware/request-timeout.d.ts

@@ -1,26 +0,0 @@
-import { Context } from "../core/context.js";
-import { HttpBaseResponse, Middleware } from "../types/index.js";
-export type TimeoutOptions = {
-    /**
-     * ⏳ Function to dynamically determine the timeout duration (in milliseconds).
-     */
-    getTimeout: (ctx: Context) => number;
-    /**
-     * 🚫 Custom function to handle timeout errors.
-     */
-    onTimeout?: (ctx: Context, error: Error) => HttpBaseResponse;
-    /**
-     * 📝 Logging function for timeout events.
-     */
-    logTimeoutEvent?: (ctx: Context, error: Error) => void;
-    /**
-     * 🛠️ Custom function to clean up resources after a timeout.
-     */
-    cleanup?: (ctx: Context) => void;
-};
-/**
- * Middleware to enforce fully dynamic request timeouts.
- * @param options - Custom options for dynamic timeout handling.
- */
-declare const requestTimeout: (options: TimeoutOptions) => Middleware;
-export { requestTimeout, requestTimeout as default };

package/middleware/request-timeout.js

@@ -1,39 +0,0 @@
-import { GlobalConfig } from "../core/config.js";
-const requestTimeout = (options) => {
-    const { getTimeout, onTimeout = (ctx) => {
-        ctx.setStatus = 504;
-        ctx.body = { error: "Request timed out." };
-    }, logTimeoutEvent = (ctx, error) => {
-        GlobalConfig.debugging.warn(`[TIMEOUT] ${error.message}: ${ctx.method} ${ctx.pathname}`);
-    }, cleanup = () => {
-    }, } = options;
-    return async function requestTimeout(ctx, next) {
-        let timeoutId = null;
-        try {
-            const timeout = getTimeout(ctx);
-            const timeoutPromise = new Promise((_, reject) => {
-                timeoutId = setTimeout(() => {
-                    const timeoutError = new Error("Request timed out.");
-                    logTimeoutEvent(ctx, timeoutError);
-                    reject(timeoutError);
-                }, timeout);
-            });
-            return await Promise.race([next(), timeoutPromise]);
-        }
-        catch (error) {
-            if (error.message === "Request timed out.") {
-                onTimeout(ctx, error);
-            }
-            else {
-                throw error;
-            }
-        }
-        finally {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-            }
-            cleanup(ctx);
-        }
-    };
-};
-export { requestTimeout, requestTimeout as default };

package/middleware/secure-headers.d.ts

@@ -1,78 +0,0 @@
-import { Context, Middleware } from "../index.js";
-export type DynamicHeaderValue = string | ((ctx: Context) => string | undefined);
-export type SecurityHeaderOptions = {
-    /**
-     * 🔵 Content Security Policy header value
-     * @default "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline';"
-     * @example
-     * contentSecurityPolicy: "default-src 'none'; script-src 'self' https://trusted.cdn.com"
-     * contentSecurityPolicy: (ctx) => ctx.isAdmin ? "default-src 'self'" : "default-src 'none'"
-     */
-    contentSecurityPolicy?: DynamicHeaderValue;
-    /**
-     * 🟢 Whether to set X-Frame-Options header (clickjacking protection)
-     * @default true
-     * @example
-     * frameGuard: true // Always enable
-     * frameGuard: (ctx) => !ctx.pathname.startsWith('/embed/') // Disable for embed routes
-     */
-    frameGuard?: boolean | ((ctx: Context) => boolean);
-    /**
-     * 🟣 HTTP Strict Transport Security (HSTS) header
-     * @default true
-     * @example
-     * hsts: true // Enable with 2 year duration
-     * hsts: (ctx) => ctx.secure // Enable only for HTTPS
-     */
-    hsts?: boolean | ((ctx: Context) => boolean);
-    /**
-     * 🟠 XSS Protection header
-     * @default true
-     * @example
-     * xssProtection: false // Disable legacy XSS filter
-     */
-    xssProtection?: boolean | ((ctx: Context) => boolean);
-    /**
-     * 🟡 X-Content-Type-Options header (MIME sniffing prevention)
-     * @default true
-     * @example
-     * noSniff: false // Only disable if you have specific needs
-     */
-    noSniff?: boolean | ((ctx: Context) => boolean);
-    /**
-     * 🔴 Referrer Policy header
-     * @default "no-referrer"
-     * @example
-     * referrerPolicy: "strict-origin-when-cross-origin"
-     */
-    referrerPolicy?: DynamicHeaderValue;
-    /**
-     * 🟤 Permissions Policy header (formerly Feature Policy)
-     * @default "geolocation=(), microphone=(), camera=()"
-     * @example
-     * permissionsPolicy: "geolocation=(self 'https://example.com')"
-     */
-    permissionsPolicy?: DynamicHeaderValue;
-};
-/**
- * 🛡️ Comprehensive security headers middleware
- *
- * Sets multiple security-related HTTP headers with dynamic configuration.
- * All headers can be configured per-request using functions.
- *
- * @param {SecurityHeaderOptions} [options={}] - Configuration options
- * @returns {Middleware} Middleware function
- *
- * @example
- * // Basic usage with defaults
- * app.use(secureHeaders());
- *
- * // Custom configuration
- * app.use(secureHeaders({
- *   contentSecurityPolicy: "default-src 'self'",
- *   frameGuard: (ctx) => !ctx.isEmbedded,
- *   referrerPolicy: "strict-origin-when-cross-origin"
- * }));
- */
-declare const secureHeaders: (options?: SecurityHeaderOptions) => Middleware<any>;
-export { secureHeaders, secureHeaders as default };

package/middleware/secure-headers.js

@@ -1,39 +0,0 @@
-const secureHeaders = (options = {}) => {
-    return async function secureHeaders(ctx, next) {
-        const resolveValue = (value) => {
-            return typeof value === "function" ? value(ctx) : value;
-        };
-        const contentSecurityPolicy = resolveValue(options.contentSecurityPolicy) ||
-            "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline';";
-        const frameGuard = resolveValue(options.frameGuard) ?? true;
-        const hsts = resolveValue(options.hsts) ?? true;
-        const xssProtection = resolveValue(options.xssProtection) ?? true;
-        const noSniff = resolveValue(options.noSniff) ?? true;
-        const referrerPolicy = resolveValue(options.referrerPolicy) || "no-referrer";
-        const permissionsPolicy = resolveValue(options.permissionsPolicy) ||
-            "geolocation=(), microphone=(), camera=()";
-        if (contentSecurityPolicy) {
-            ctx.setHeader("Content-Security-Policy", contentSecurityPolicy);
-        }
-        if (frameGuard) {
-            ctx.setHeader("X-Frame-Options", "DENY");
-        }
-        if (hsts) {
-            ctx.setHeader("Strict-Transport-Security", "max-age=63072000; includeSubDomains");
-        }
-        if (xssProtection) {
-            ctx.setHeader("X-XSS-Protection", "1; mode=block");
-        }
-        if (noSniff) {
-            ctx.setHeader("X-Content-Type-Options", "nosniff");
-        }
-        if (referrerPolicy) {
-            ctx.setHeader("Referrer-Policy", referrerPolicy);
-        }
-        if (permissionsPolicy) {
-            ctx.setHeader("Permissions-Policy", permissionsPolicy);
-        }
-        return await next();
-    };
-};
-export { secureHeaders, secureHeaders as default };