tezx 2.0.11 → 3.0.0

package/cjs/middleware/basicAuth.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.basicAuth = void 0;
-const config_js_1 = require("../core/config.js");
-const colors_js_1 = require("../utils/colors.js");
-const detectBot_js_1 = require("./detectBot.js");
-const basicAuth = (options) => {
-    const { validateCredentials, getRealm = () => "Restricted Area", onUnauthorized = (ctx, error) => {
-        const realm = getRealm(ctx);
-        ctx.setStatus = 401;
-        ctx.header("WWW-Authenticate", `Basic realm="${realm}"`);
-        ctx.body = { error: error?.message };
-    }, rateLimit, supportedMethods = ["basic", "api-key", "bearer-token"], checkAccess, } = options;
-    let storage = rateLimit?.storage;
-    if (rateLimit && !rateLimit.storage) {
-        storage = (0, detectBot_js_1.createRateLimitDefaultStorage)();
-    }
-    return async function basicAuth(ctx, next) {
-        let authMethod;
-        let credentials = {};
-        const authHeader = ctx.req.headers.get("authorization");
-        if (authHeader) {
-            if (authHeader.startsWith("Basic ")) {
-                authMethod = "basic";
-                const base64Credentials = authHeader.split(" ")[1];
-                const decoded = Buffer.from(base64Credentials, "base64").toString("utf-8");
-                const [username, password] = decoded.split(":");
-                credentials = { username, password };
-            }
-            else if (authHeader.startsWith("Bearer ")) {
-                authMethod = "bearer-token";
-                credentials = { token: authHeader.split(" ")[1] };
-            }
-        }
-        else if (ctx.headers.get("x-api-key")) {
-            authMethod = "api-key";
-            credentials = { apiKey: ctx.headers.get("x-api-key") };
-        }
-        if (!authMethod || !supportedMethods.includes(authMethod)) {
-            config_js_1.GlobalConfig.debugging.error(`${(0, colors_js_1.colorText)("[AUTH]", "bgRed")} Unsupported or missing authentication method.`);
-            return onUnauthorized(ctx, new Error("Unsupported authentication method"));
-        }
-        if (rateLimit) {
-            let key = `${ctx.req.remoteAddress.address}:${ctx.req.remoteAddress.port}`;
-            const { check, entry } = (0, detectBot_js_1.isRateLimit)(ctx, key, storage, rateLimit.maxRequests, rateLimit.windowMs);
-            if (check) {
-                const retryAfter = Math.ceil((entry.resetTime - Date.now()) / 1000);
-                ctx.headers.set("Retry-After", retryAfter.toString());
-                return onUnauthorized(ctx, new Error(`Rate limit exceeded. Retry after ${retryAfter} seconds.`));
-            }
-        }
-        try {
-            const isValid = await validateCredentials(authMethod, credentials, ctx);
-            if (!isValid) {
-                throw new Error("Invalid credentials.");
-            }
-            if (checkAccess) {
-                const hasAccess = await checkAccess(ctx, credentials);
-                if (!hasAccess) {
-                    return onUnauthorized(ctx, new Error("Access denied."));
-                }
-            }
-            return await next();
-        }
-        catch (error) {
-            config_js_1.GlobalConfig.debugging.error(`${(0, colors_js_1.colorText)("[AUTH]", "bgRed")} Failure for method: ${ctx.method}`);
-            return onUnauthorized(ctx, error);
-        }
-    };
-};
-exports.basicAuth = basicAuth;

package/cjs/middleware/cacheControl.js

@@ -1,90 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cacheControl = void 0;
-const config_js_1 = require("../core/config.js");
-const cacheControl = (options) => {
-    const { defaultSettings, useWeakETag = false, rules = [], logEvent = (event, ctx, error) => {
-        if (event === "error") {
-            config_js_1.GlobalConfig.debugging.error(`[CACHE] ${event.toUpperCase()}: ${error?.message}`);
-        }
-        else {
-            config_js_1.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.header("Cache-Control", cacheControlValue);
-            const expiresDate = new Date(Date.now() + maxAge * 1000).toUTCString();
-            ctx.header("Expires", expiresDate);
-            if (vary?.length) {
-                ctx.header("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.headers.get("if-none-match");
-                if (ifNoneMatch === etag) {
-                    ctx.setStatus = 304;
-                    ctx.body = null;
-                    logEvent("cached", ctx);
-                    return;
-                }
-                ctx.header("ETag", etag);
-            }
-            logEvent("cached", ctx);
-        }
-        catch (error) {
-            logEvent("error", ctx, error);
-            ctx.setStatus = 500;
-            ctx.body = { error: "Failed to set cache headers." };
-        }
-    };
-};
-exports.cacheControl = cacheControl;
-const generateETag = async (content, weak = false) => {
-    const crypto = await Promise.resolve().then(() => __importStar(require("node:crypto")));
-    const hash = crypto.createHash("md5").update(content).digest("hex");
-    return weak ? `W/"${hash}"` : `"${hash}"`;
-};

package/cjs/middleware/detectBot.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectBot = void 0;
-exports.createRateLimitDefaultStorage = createRateLimitDefaultStorage;
-exports.isRateLimit = isRateLimit;
-const config_js_1 = require("../core/config.js");
-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.headers.get("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) {
-            config_js_1.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();
-    };
-};
-exports.detectBot = detectBot;
-function createRateLimitDefaultStorage() {
-    const store = new Map();
-    return {
-        get: (key) => store.get(key),
-        set: (key, value) => store.set(key, value),
-        clearExpired: () => {
-            const now = Date.now();
-            for (const [key, entry] of store.entries()) {
-                if (now >= entry.resetTime) {
-                    store.delete(key);
-                }
-            }
-        },
-    };
-}
-function isRateLimit(ctx, key, store, maxRequests, windowMs) {
-    store.clearExpired();
-    const now = Date.now();
-    let entry = store.get(key) || { count: 0, resetTime: now + windowMs };
-    if (now < entry.resetTime) {
-        entry.count++;
-        if (entry.count > maxRequests) {
-            return {
-                check: true,
-                entry: entry,
-            };
-        }
-    }
-    else {
-        entry = { count: 1, resetTime: now + windowMs };
-    }
-    store.set(key, entry);
-    return {
-        check: false,
-        entry: entry,
-    };
-}

package/cjs/middleware/detectLocale.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectLocale = void 0;
-const config_js_1 = require("../core/config.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 = ctx.cookies.get(cookieKeyLocale);
-            if (cookieLocale && supportedLocales.includes(cookieLocale)) {
-                detectedLocale = cookieLocale;
-            }
-        }
-        if (!detectedLocale) {
-            const acceptLanguage = ctx.req.headers.get("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;
-        config_js_1.GlobalConfig.debugging.success(`Detected locale: ${detectedLocale}`);
-        return await next();
-    };
-};
-exports.detectLocale = detectLocale;

package/cjs/middleware/lazyLoadModules.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lazyLoadModules = void 0;
-const config_js_1 = require("../core/config.js");
-const lazyLoadModules = (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 lazyLoadModules(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.lazyLoadModules = lazyLoadModules;

package/cjs/middleware/rateLimiter.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rateLimiter = void 0;
-const detectBot_js_1 = require("./detectBot.js");
-const rateLimiter = (options) => {
-    const { maxRequests, windowMs, keyGenerator = (ctx) => `${ctx.req.remoteAddress.address}:${ctx.req.remoteAddress.port}`, storage = (0, detectBot_js_1.createRateLimitDefaultStorage)(), onError = (ctx, retryAfter, error) => {
-        ctx.setStatus = 429;
-        throw new Error(`Rate limit exceeded. Try again in ${retryAfter} seconds.`);
-    }, } = options;
-    return async function rateLimiter(ctx, next) {
-        const key = keyGenerator(ctx);
-        const { check, entry } = (0, detectBot_js_1.isRateLimit)(ctx, 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 Error(`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();
-    };
-};
-exports.rateLimiter = rateLimiter;

package/cjs/middleware/requestTimeout.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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.path}`);
-    }, 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;

package/cjs/middleware/sanitizeHeader.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitizeHeaders = void 0;
-const config_js_1 = require("../core/config.js");
-const sanitizeHeaders = (options = {}) => {
-    const { whitelist = [], blacklist = [], normalizeKeys = true, allowUnsafeCharacters = false, } = options;
-    return async function sanitizeHeaders(ctx, next) {
-        const sanitizedHeaders = new Map();
-        for (const [key, values] of ctx.headers.entries()) {
-            if (!Array.isArray(values) || values.length === 0) {
-                continue;
-            }
-            const normalizedKey = normalizeKeys ? key.toLowerCase() : key;
-            if (whitelist.length > 0 &&
-                !whitelist.some((r) => r?.toLowerCase() === normalizedKey)) {
-                config_js_1.GlobalConfig.debugging.warn(`🚫 Header "${normalizedKey}" not in whitelist - removed`);
-                continue;
-            }
-            if (blacklist.some((r) => r.toLowerCase() === normalizedKey)) {
-                config_js_1.GlobalConfig.debugging.warn(`🚫 Header "${normalizedKey}" in blacklist - removed`);
-                continue;
-            }
-            if (!isValidHeaderName(normalizedKey)) {
-                config_js_1.GlobalConfig.debugging.warn(`⚠️ Invalid header name: "${normalizedKey}" - removed`);
-                continue;
-            }
-            const sanitizedValues = values
-                .map((value) => sanitizeHeaderValue(value, allowUnsafeCharacters))
-                .filter(Boolean);
-            if (sanitizedValues.length === 0) {
-                config_js_1.GlobalConfig.debugging.warn(`⚠️ All values for "${normalizedKey}" invalid - removed`);
-                continue;
-            }
-            sanitizedHeaders.set(normalizedKey, sanitizedValues?.join(", "));
-        }
-        ctx.headers = new Headers(sanitizedHeaders);
-        return await next();
-    };
-};
-exports.sanitizeHeaders = sanitizeHeaders;
-const isValidHeaderName = (name) => {
-    const HEADER_NAME_REGEX = /^[a-zA-Z0-9\-_]+$/;
-    return HEADER_NAME_REGEX.test(name);
-};
-const sanitizeHeaderValue = (value, allowUnsafeCharacters) => {
-    let sanitized = value.trim();
-    if (!allowUnsafeCharacters) {
-        sanitized = sanitized.replace(/[\x00-\x1F\x7F]/g, "");
-    }
-    return sanitized;
-};

package/cjs/middleware/secureHeaders.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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.headers.set("Content-Security-Policy", contentSecurityPolicy);
-        }
-        if (frameGuard) {
-            ctx.headers.set("X-Frame-Options", "DENY");
-        }
-        if (hsts) {
-            ctx.headers.set("Strict-Transport-Security", "max-age=63072000; includeSubDomains");
-        }
-        if (xssProtection) {
-            ctx.headers.set("X-XSS-Protection", "1; mode=block");
-        }
-        if (noSniff) {
-            ctx.headers.set("X-Content-Type-Options", "nosniff");
-        }
-        if (referrerPolicy) {
-            ctx.headers.set("Referrer-Policy", referrerPolicy);
-        }
-        if (permissionsPolicy) {
-            ctx.headers.set("Permissions-Policy", permissionsPolicy);
-        }
-        return await next();
-    };
-};
-exports.secureHeaders = secureHeaders;