tezx 3.0.9-beta → 3.0.11-beta

package/cjs/middleware/i18n.js

@@ -1,93 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = exports.i18n = void 0;
-const config_js_1 = require("../core/config.js");
-const cookie_js_1 = require("../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 ((0, cookie_js_1.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) {
-                    config_js_1.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) {
-            config_js_1.GlobalConfig.debugging.error("i18n processing error:", error);
-            ctx.setStatus = 500;
-            throw error;
-        }
-    };
-};
-exports.i18n = i18n;
-exports.default = i18n;

package/cjs/middleware/lazy-loader.js

@@ -1,74 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = exports.lazyLoader = void 0;
-const config_js_1 = require("../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) {
-            config_js_1.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 {
-                        config_js_1.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);
-            config_js_1.GlobalConfig.debugging.success(`Successfully loaded module: ${moduleName}`);
-        }
-        catch (error) {
-            config_js_1.GlobalConfig.debugging.error(`Error loading module: ${moduleName}`, error);
-            lifecycleHooks.onError?.(moduleName, error, ctx);
-            ctx.setStatus = 500;
-            throw error;
-        }
-        return await next();
-    };
-};
-exports.lazyLoader = lazyLoader;
-exports.default = lazyLoader;

package/cjs/middleware/request-timeout.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = exports.requestTimeout = void 0;
-const config_js_1 = require("../core/config.js");
-const requestTimeout = (options) => {
-    const { getTimeout, onTimeout = (ctx) => {
-        ctx.setStatus = 504;
-        ctx.body = { error: "Request timed out." };
-    }, logTimeoutEvent = (ctx, error) => {
-        config_js_1.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);
-        }
-    };
-};
-exports.requestTimeout = requestTimeout;
-exports.default = requestTimeout;

package/cjs/middleware/secure-headers.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = exports.secureHeaders = void 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();
-    };
-};
-exports.secureHeaders = secureHeaders;
-exports.default = secureHeaders;

package/middleware/cache-control.d.ts

@@ -1,56 +0,0 @@
-import { Context } from "../core/context.js";
-import { HttpBaseResponse, Middleware } from "../types/index.js";
-export type CacheRule = {
-    /**
-     * 🎯 Condition to determine if this rule applies.
-     */
-    condition: (ctx: Context) => boolean;
-    /**
-     * ⏳ Maximum age (in seconds) for caching.
-     */
-    maxAge: number;
-    /**
-     * 🌐 Cache scope: "public" or "private".
-     */
-    scope: "public" | "private";
-    /**
-     * 🔄 Enable or disable revalidation with ETag.
-     */
-    enableETag: boolean;
-    /**
-     * 🏷️ Vary header for cache variations.
-     */
-    vary?: string[];
-};
-export type CacheSettings = Pick<CacheRule, "maxAge" | "scope" | "enableETag" | "vary">;
-export type CacheOptions = {
-    /**
-     * 🧪 Weak ETag generation (optional).
-     */
-    useWeakETag?: boolean;
-    /**
-     * Error handler for cache middleware.
-     * @param error - The error that occurred.
-     * @param ctx - The current request context.
-     * @returns An HTTP response to send when an error occurs.
-     */
-    onError?: (error: Error, ctx: Context) => HttpBaseResponse;
-    /**
-     * 📝 Logging function for cache events.
-     */
-    logEvent?: (event: "cached" | "no-cache" | "error", ctx: Context, error?: Error) => void;
-    /**
-     * 🛠️ Default cache settings.
-     */
-    defaultSettings: CacheSettings;
-    /**
-     * 🔧 Custom rules for dynamic caching behavior.
-     */
-    rules?: CacheRule[];
-};
-/**
- * Middleware to manage HTTP caching headers dynamically.
- * @param options - Custom options for dynamic caching behavior.
- */
-declare const cacheControl: (options: CacheOptions) => Middleware;
-export { cacheControl, cacheControl as default };

package/middleware/cache-control.js

@@ -1,56 +0,0 @@
-import { GlobalConfig } from "../core/config.js";
-const cacheControl = (options) => {
-    const { defaultSettings, useWeakETag = false, rules = [], onError = (error, ctx) => {
-        ctx.setStatus = 500;
-        ctx.body = { error: "Failed to set cache headers." };
-    }, logEvent = (event, ctx, error) => {
-        if (event === "error") {
-            GlobalConfig.debugging.error(`[CACHE] ${event.toUpperCase()}: ${error?.message}`);
-        }
-        else {
-            GlobalConfig.debugging.success(`[CACHE] ${event.toUpperCase()} for ${ctx.method} ${ctx.pathname}`);
-        }
-    }, } = options;
-    return async function cacheControl(ctx, next) {
-        if (!["GET", "HEAD"].includes(ctx.method)) {
-            return await next();
-        }
-        try {
-            await next();
-            const matchedRule = rules.find((rule) => rule.condition(ctx)) || null;
-            const { maxAge, scope, enableETag, vary } = matchedRule || defaultSettings;
-            const cacheControlValue = `${scope}, max-age=${maxAge}`;
-            ctx.setHeader("Cache-Control", cacheControlValue);
-            const expiresDate = new Date(Date.now() + maxAge * 1000).toUTCString();
-            ctx.setHeader("Expires", expiresDate);
-            if (vary?.length) {
-                ctx.setHeader("Vary", vary.join(", "));
-            }
-            if (enableETag) {
-                const responseBody = typeof ctx.resBody === "string"
-                    ? ctx.resBody
-                    : JSON.stringify(ctx.resBody ?? "");
-                const etag = await generateETag(responseBody, useWeakETag);
-                const ifNoneMatch = ctx.req.header("if-none-match");
-                if (ifNoneMatch === etag) {
-                    ctx.setStatus = 304;
-                    ctx.body = null;
-                    logEvent("cached", ctx);
-                    return;
-                }
-                ctx.setHeader("ETag", etag);
-            }
-            logEvent("cached", ctx);
-        }
-        catch (error) {
-            logEvent("error", ctx, error);
-            return onError?.(error, ctx);
-        }
-    };
-};
-const generateETag = async (content, weak = false) => {
-    const crypto = await import("node:crypto");
-    const hash = crypto.createHash("md5").update(content).digest("hex");
-    return weak ? `W/"${hash}"` : `"${hash}"`;
-};
-export { cacheControl, cacheControl as default };

package/middleware/detect-bot.d.ts

@@ -1,111 +0,0 @@
-import { Context, Middleware } from "../index.js";
-import { HttpBaseResponse } from "../types/index.js";
-export type DetectBotReason = "User-Agent" | "Blacklisted IP" | "Query Parameter" | "Rate Limiting" | "Custom Detector" | "Multiple Indicators";
-export type BotDetectionResult = {
-    isBot: boolean;
-    reason?: DetectBotReason;
-    indicators: string[];
-};
-export type DetectBotOptions = {
-    /**
-     * 🤖 List of bot-like user-agent substrings to detect
-     * @default ["bot", "spider", "crawl", "slurp"]
-     */
-    botUserAgents?: string[];
-    /**
-     * ⚠️ Maximum allowed requests in the time window
-     * @default 30 requests
-     */
-    maxRequests?: number;
-    /**
-     * ⏱️ Time window in milliseconds for rate limiting
-     * @default 60000 (1 minute)
-     */
-    windowMs?: number;
-    /**
-     * 🚫 IP blacklist checker
-     * @default () => false
-     */
-    isBlacklisted?: (ctx: Context, remoteAddress: string) => boolean | Promise<boolean>;
-    /**
-     * 🔍 Query parameter name for bot identification
-     * @default "bot"
-     */
-    queryKeyBot?: string;
-    /**
-     * 🛡️ Action to take when bot is detected
-     * @default "block"
-     */
-    onBotDetected?: "block" | ((ctx: Context, result: BotDetectionResult) => HttpBaseResponse);
-    /**
-     * ⚖️ Enable rate-limiting based detection
-     * @default false
-     */
-    enableRateLimiting?: boolean;
-    /**
-     * 🔎 Custom bot detection logic
-     * @default () => false
-     */
-    customBotDetector?: (ctx: Context) => boolean | Promise<boolean>;
-    /**
-     * ✉️ Custom response for blocked requests
-     */
-    customBlockedResponse?: (ctx: Context, result: BotDetectionResult) => HttpBaseResponse;
-    /**
-     * 🔄 Custom cache storage implementation (e.g., using `Map`, `Redis`, etc.).
-     * By default, it uses a `Map<string, { count: number; resetTime: number }>`.
-     */
-    storage?: {
-        get: (key: string) => {
-            count: number;
-            resetTime: number;
-        } | undefined;
-        set: (key: string, value: {
-            count: number;
-            resetTime: number;
-        }) => void;
-        clearExpired: () => void;
-    };
-    /**
-     * 📊 Minimum confidence score to consider as bot (0-1)
-     * @default 0.5
-     */
-    confidenceThreshold?: number;
-};
-/**
- * 🤖 Advanced bot detection middleware with multiple detection methods
- * @requires
- *
-```ts
-  import { getConnInfo } from "tezx/bun";
-  // or
-  import { getConnInfo } from "tezx/deno";
-  // or
-  import { getConnInfo } from "tezx/node";
-```
- * Features:
- * - User-Agent analysis
- * - IP blacklisting
- * - Query parameter detection
- * - Rate limiting
- * - Custom detection logic
- * - Confidence-based scoring
- *
- * @param {DetectBotOptions} options - Configuration options
- * @returns {Middleware} Configured middleware
- *
- * @example
- * // Basic usage
- * app.use(detectBot());
- *
- * // Custom configuration
- * app.use(detectBot({
- *   botUserAgents: ["bot", "crawler"],
- *   isBlacklistedIP: async (ip) => await checkIPReputation(ip),
- *   onBotDetected: (ctx, { reason }) => {
- *     ctx.status = 403;
- *     return ctx.json({ error: `Bot detected (${reason})` });
- *   }
- * }));
- */
-export declare const detectBot: (options?: DetectBotOptions) => Middleware;

package/middleware/detect-bot.js

@@ -1,62 +0,0 @@
-import { GlobalConfig } from "../core/config.js";
-import { createRateLimitDefaultStorage, isRateLimit, } from "../utils/rateLimit.js";
-export const detectBot = (options = {}) => {
-    const { botUserAgents = ["bot", "spider", "crawl", "slurp"], maxRequests = 30, windowMs = 60000, isBlacklisted = async () => false, queryKeyBot = "bot", onBotDetected = "block", enableRateLimiting = false, customBotDetector = async () => false, customBlockedResponse = (ctx, { reason }) => {
-        ctx.setStatus = 403;
-        return ctx.json({ error: `Bot detected: ${reason}` });
-    }, storage, confidenceThreshold = 0.5, } = options;
-    let store = storage;
-    if (enableRateLimiting) {
-        store = createRateLimitDefaultStorage();
-    }
-    return async function detectBot(ctx, next) {
-        const detectionResult = {
-            isBot: false,
-            indicators: [],
-        };
-        const userAgent = ctx.header("user-agent")?.toLowerCase() || "";
-        const remoteAddress = `${ctx.req.remoteAddress?.address}:${ctx.req.remoteAddress?.port}` ||
-            "unknown";
-        const isBotQuery = ctx.req.query[queryKeyBot] === "true";
-        if (botUserAgents.some((agent) => userAgent.includes(agent))) {
-            detectionResult.indicators.push("User-Agent");
-        }
-        if (await isBlacklisted(ctx, remoteAddress)) {
-            detectionResult.indicators.push("Blacklisted IP");
-        }
-        if (isBotQuery) {
-            detectionResult.indicators.push("Query Parameter");
-        }
-        const key = `${ctx.req.remoteAddress.address}:${ctx.req.remoteAddress.port}`;
-        if (enableRateLimiting &&
-            isRateLimit(ctx, key, store, maxRequests, windowMs).check) {
-            detectionResult.indicators.push("Rate Limiting");
-        }
-        if (await customBotDetector(ctx)) {
-            detectionResult.indicators.push("Custom Detector");
-        }
-        detectionResult.isBot = detectionResult.indicators.length > 0;
-        if (detectionResult.indicators.length > 1) {
-            detectionResult.reason = "Multiple Indicators";
-            const confidence = Math.min(0.3 * detectionResult.indicators.length, 1);
-            detectionResult.isBot = confidence >= confidenceThreshold;
-        }
-        else if (detectionResult.indicators.length === 1) {
-            detectionResult.reason = detectionResult.indicators[0];
-        }
-        if (detectionResult.isBot) {
-            GlobalConfig.debugging.warn(`Bot detected: ${detectionResult.reason}`, {
-                ip: remoteAddress,
-                userAgent,
-                indicators: detectionResult.indicators,
-            });
-            if (onBotDetected === "block") {
-                return customBlockedResponse(ctx, detectionResult);
-            }
-            else if (typeof onBotDetected === "function") {
-                return onBotDetected(ctx, detectionResult);
-            }
-        }
-        return await next();
-    };
-};

package/middleware/detect-locale.d.ts

@@ -1,56 +0,0 @@
-import { Context, Middleware } from "../index.js";
-/**
- * Options for the detectLocale middleware.
- */
-export type DetectLocaleOptions = {
-    /**
-     * 🌐 List of allowed locales.
-     * e.g., ["en", "fr", "bn"]
-     */
-    supportedLocales: string[];
-    /**
-     * 🏠 Default locale if none is matched from query, cookie, or headers.
-     * @default "en"
-     */
-    defaultLocale?: string;
-    /**
-     * 🔍 Name of the query parameter to check for locale.
-     * Example: /?lang=fr
-     * @default "lang"
-     */
-    queryKeyLocale?: string;
-    /**
-     * 🍪 Name of the cookie used to store locale preference.
-     * @default "locale"
-     */
-    cookieKeyLocale?: string;
-    /**
-     * 🗺️ Key under which the locale will be attached to the context object.
-     * Example: ctx.locale = "en"
-     * @default "locale"
-     */
-    localeContextKey?: string;
-    /**
-     * 🛠️ Optional custom function to programmatically detect locale.
-     * Called last before fallback.
-     * Should return a supported locale or undefined.
-     */
-    customLocaleDetector?: (ctx: Context) => string | undefined;
-};
-/**
- * 🌍 Middleware that detects and sets the user's preferred locale.
- *
- * Detection order:
- * 1. Query parameter (e.g., ?lang=fr)
- * 2. Cookie value (e.g., locale=fr)
- * 3. Accept-Language HTTP header
- * 4. Custom detector function (if provided)
- * 5. Default locale (fallback)
- *
- * The detected locale is stored in `ctx[localeContextKey]`.
- *
- * @param options - Configuration options for locale detection.
- * @returns Middleware function that attaches locale to the context.
- */
-declare const detectLocale: (options: DetectLocaleOptions) => Middleware;
-export { detectLocale, detectLocale as default };

package/middleware/detect-locale.js

@@ -1,41 +0,0 @@
-import { GlobalConfig } from "../core/config.js";
-import { getCookie } from "../utils/cookie.js";
-const detectLocale = (options) => {
-    const { supportedLocales, defaultLocale = "en", queryKeyLocale = "lang", cookieKeyLocale = "locale", localeContextKey = "locale", customLocaleDetector, } = options;
-    return async function detectLocale(ctx, next) {
-        let detectedLocale;
-        const queryLocale = ctx.req.query[queryKeyLocale];
-        if (queryLocale && supportedLocales.includes(queryLocale)) {
-            detectedLocale = queryLocale;
-        }
-        if (!detectedLocale) {
-            const cookieLocale = getCookie(ctx, cookieKeyLocale);
-            if (cookieLocale && supportedLocales.includes(cookieLocale)) {
-                detectedLocale = cookieLocale;
-            }
-        }
-        if (!detectedLocale) {
-            const acceptLanguage = ctx.req.header("accept-language");
-            if (acceptLanguage) {
-                const preferredLocales = acceptLanguage
-                    .split(",")
-                    .map((lang) => lang.split(";")[0].trim())
-                    .filter((lang) => supportedLocales.includes(lang));
-                detectedLocale = preferredLocales[0];
-            }
-        }
-        if (!detectedLocale && customLocaleDetector) {
-            const customLocale = customLocaleDetector(ctx);
-            if (customLocale && supportedLocales.includes(customLocale)) {
-                detectedLocale = customLocale;
-            }
-        }
-        if (!detectedLocale) {
-            detectedLocale = defaultLocale;
-        }
-        ctx[localeContextKey] = detectedLocale;
-        GlobalConfig.debugging.success(`Detected locale: ${detectedLocale}`);
-        return await next();
-    };
-};
-export { detectLocale, detectLocale as default };