tezx 2.0.11 → 3.0.0

package/cjs/middleware/index.js

@@ -14,55 +14,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectBot = void 0;
-const basicAuth_js_1 = require("./basicAuth.js");
-const cacheControl_js_1 = require("./cacheControl.js");
-const cors_js_1 = require("./cors.js");
-const detectBot_js_1 = require("./detectBot.js");
-const detectLocale_js_1 = require("./detectLocale.js");
-const i18n_js_1 = require("./i18n.js");
-const lazyLoadModules_js_1 = require("./lazyLoadModules.js");
-const logger_js_1 = require("./logger.js");
-const pagination_js_1 = require("./pagination.js");
-const powered_by_js_1 = require("./powered-by.js");
-const rateLimiter_js_1 = require("./rateLimiter.js");
-const request_id_js_1 = require("./request-id.js");
-const requestTimeout_js_1 = require("./requestTimeout.js");
-const sanitizeHeader_js_1 = require("./sanitizeHeader.js");
-const secureHeaders_js_1 = require("./secureHeaders.js");
-const xssProtection_js_1 = require("./xssProtection.js");
-__exportStar(require("./basicAuth.js"), exports);
-__exportStar(require("./cacheControl.js"), exports);
+__exportStar(require("./basic-auth.js"), exports);
+__exportStar(require("./bearer-auth.js"), exports);
+__exportStar(require("./cache-control.js"), exports);
 __exportStar(require("./cors.js"), exports);
-var detectBot_js_2 = require("./detectBot.js");
-Object.defineProperty(exports, "detectBot", { enumerable: true, get: function () { return detectBot_js_2.detectBot; } });
-__exportStar(require("./detectLocale.js"), exports);
+__exportStar(require("./detect-bot.js"), exports);
 __exportStar(require("./i18n.js"), exports);
-__exportStar(require("./lazyLoadModules.js"), exports);
 __exportStar(require("./logger.js"), exports);
 __exportStar(require("./pagination.js"), exports);
 __exportStar(require("./powered-by.js"), exports);
-__exportStar(require("./rateLimiter.js"), exports);
+__exportStar(require("./rate-limiter.js"), exports);
 __exportStar(require("./request-id.js"), exports);
-__exportStar(require("./requestTimeout.js"), exports);
-__exportStar(require("./sanitizeHeader.js"), exports);
-__exportStar(require("./secureHeaders.js"), exports);
-__exportStar(require("./xssProtection.js"), exports);
-exports.default = {
-    basicAuth: basicAuth_js_1.basicAuth,
-    cacheControl: cacheControl_js_1.cacheControl,
-    cors: cors_js_1.cors,
-    detectBot: detectBot_js_1.detectBot,
-    detectLocale: detectLocale_js_1.detectLocale,
-    i18n: i18n_js_1.i18n,
-    lazyLoadModules: lazyLoadModules_js_1.lazyLoadModules,
-    logger: logger_js_1.logger,
-    paginationHandler: pagination_js_1.paginationHandler,
-    poweredBy: powered_by_js_1.poweredBy,
-    rateLimiter: rateLimiter_js_1.rateLimiter,
-    requestID: request_id_js_1.requestID,
-    requestTimeout: requestTimeout_js_1.requestTimeout,
-    sanitizeHeaders: sanitizeHeader_js_1.sanitizeHeaders,
-    secureHeaders: secureHeaders_js_1.secureHeaders,
-    xssProtection: xssProtection_js_1.xssProtection,
-};
+__exportStar(require("./sanitize-headers.js"), exports);
+__exportStar(require("./secure-headers.js"), exports);
+__exportStar(require("./xss-protection.js"), exports);

package/cjs/middleware/logger.js

@@ -1,21 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = logger;
 exports.logger = logger;
+const error_js_1 = require("../core/error.js");
 const colors_js_1 = require("../utils/colors.js");
-function logger() {
+function logger(options = { enabled: true }) {
     return async function logger(ctx, next) {
         try {
+            if (!options?.enabled) {
+                return next();
+            }
             console.log(`${(0, colors_js_1.colorText)("<--", "bold")} ${(0, colors_js_1.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(`${(0, colors_js_1.colorText)("-->", "bold")} ${(0, colors_js_1.colorText)(ctx.method, "bgBlue")} ${ctx.pathname} ` +
-                `${(0, colors_js_1.colorText)(ctx.getStatus, "yellow")} ${(0, colors_js_1.colorText)(`${elapsed.toFixed(2)}ms`, "magenta")}`);
+                `${(0, colors_js_1.colorText)(n ? ctx.getStatus : 404, "yellow")} ${(0, colors_js_1.colorText)(`${elapsed.toFixed(2)}ms`, "magenta")}`);
             return n;
         }
         catch (err) {
             console.error(`${(0, colors_js_1.colorText)("Error:", "red")}`, err.stack);
-            throw new Error(err.stack);
+            throw new error_js_1.TezXError(err.stack);
         }
     };
 }

package/cjs/middleware/pagination.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.paginationHandler = void 0;
+exports.default = exports.paginationHandler = void 0;
 const paginationHandler = (options = {}) => {
-    const { defaultPage = 1, defaultLimit = 10, maxLimit = 100, queryKeyPage = "page", queryKeyLimit = "limit", countKey = "total", dataKey = "data", getDataSource, } = 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];
@@ -51,3 +51,4 @@ const paginationHandler = (options = {}) => {
     };
 };
 exports.paginationHandler = paginationHandler;
+exports.default = paginationHandler;

package/cjs/middleware/powered-by.js

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

package/cjs/middleware/rate-limiter.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.rateLimiter = void 0;
+const error_js_1 = require("../core/error.js");
+const rateLimit_js_1 = require("../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 = (0, rateLimit_js_1.createRateLimitDefaultStorage)(), onError = (ctx, retryAfter, error) => {
+        ctx.setStatus = 429;
+        throw new error_js_1.TezXError(`Rate limit exceeded. Try again in ${retryAfter} seconds.`, 429);
+    }, } = options;
+    return async function rateLimiter(ctx, next) {
+        const key = keyGenerator(ctx);
+        const { check, entry } = (0, rateLimit_js_1.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 error_js_1.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();
+    };
+};
+exports.rateLimiter = rateLimiter;
+exports.default = rateLimiter;

package/cjs/middleware/request-id.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requestID = void 0;
+exports.requestID = exports.default = void 0;
 const index_js_1 = require("../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-${(0, index_js_1.generateID)()}`;
+        let requestId = ctx.headers.get(headerName) ?? `req-${(0, index_js_1.generateUUID)()}`;
         ctx[contextKey] = requestId;
-        ctx.header(headerName, requestId);
+        ctx.headers.set(headerName, requestId);
         return next();
     };
 };
+exports.default = requestID;
 exports.requestID = requestID;

package/cjs/middleware/sanitize-headers.js

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

package/cjs/middleware/secure-headers copy.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secureHeaders = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const joinSrc = (v) => typeof v === "string" ? v : v.join(" ");
+const buildCSPString = (cspObj) => {
+    const parts = [];
+    for (const key in cspObj) {
+        parts.push(`${key} ${joinSrc(cspObj[key])}`);
+    }
+    return parts.join("; ");
+};
+const defaultPresets = {
+    strict: {
+        preset: "strict",
+        hsts: true,
+        hstsMaxAge: 63072000,
+        frameGuard: "DENY",
+        noSniff: true,
+        xssProtection: true,
+        referrerPolicy: "strict-origin-when-cross-origin",
+        permissionsPolicy: "geolocation=(), microphone=(), camera=(), usb=()",
+        csp: {
+            "default-src": ["'self'"],
+            "script-src": ["'self'"],
+            "style-src": ["'self'", "'unsafe-inline'"],
+            "img-src": ["'self'", "data:", "blob:"],
+            "font-src": ["'self'"],
+            "connect-src": ["'self'"],
+            "object-src": ["'none'"],
+            "frame-ancestors": ["'none'"],
+        },
+        cspReportOnly: false,
+    },
+    balanced: {
+        preset: "balanced",
+        hsts: true,
+        hstsMaxAge: 31536000,
+        frameGuard: "SAMEORIGIN",
+        noSniff: true,
+        xssProtection: true,
+        referrerPolicy: "no-referrer-when-downgrade",
+        permissionsPolicy: "geolocation=(), microphone=()",
+        csp: {
+            "default-src": ["'self'"],
+            "script-src": ["'self'", "https://cdn.jsdelivr.net"],
+            "style-src": [
+                "'self'",
+                "'unsafe-inline'",
+                "https://fonts.googleapis.com",
+            ],
+            "img-src": ["'self'", "data:", "https://images.example.com"],
+            "connect-src": ["'self'", "https://api.example.com"],
+        },
+        cspReportOnly: true,
+    },
+    dev: {
+        preset: "dev",
+        hsts: false,
+        frameGuard: "SAMEORIGIN",
+        noSniff: false,
+        xssProtection: false,
+        referrerPolicy: "no-referrer",
+        permissionsPolicy: "",
+        csp: {
+            "default-src": [
+                "'self'",
+                "'unsafe-inline'",
+                "'unsafe-eval'",
+                "http://localhost:3000",
+            ],
+            "img-src": ["'self'", "data:", "blob:"],
+        },
+        cspReportOnly: true,
+    },
+};
+const setHeader = (ctx, name, value) => {
+    if (typeof ctx.setHeader === "function")
+        ctx.setHeader(name, value);
+    else if (ctx.response?.setHeader)
+        ctx.response.setHeader(name, value);
+    else if (ctx.headersOut)
+        ctx.headersOut[name] = value;
+};
+const secureHeaders = (userOpts = {}) => {
+    const preset = userOpts.preset ?? "balanced";
+    const base = {
+        ...(defaultPresets[preset] || defaultPresets.balanced),
+        ...userOpts,
+    };
+    const hstsHeader = base.hsts
+        ? `max-age=${base.hstsMaxAge || 31536000}; includeSubDomains; preload`
+        : "";
+    const frameHeader = base.frameGuard || "SAMEORIGIN";
+    const noSniffHeader = base.noSniff ? "nosniff" : "";
+    const xssHeader = base.xssProtection ? "1; mode=block" : "0";
+    const referrerHeader = base.referrerPolicy || "no-referrer";
+    const permissionsHeader = base.permissionsPolicy || "";
+    let cspStatic = null;
+    let cspNeedsNonce = !!base.cspUseNonce;
+    if (typeof base.csp === "string")
+        cspStatic = base.csp;
+    else if (base.csp && typeof base.csp === "object")
+        cspStatic = buildCSPString(base.csp);
+    if (base.ultraFastMode)
+        cspNeedsNonce = false;
+    const cspReportOnly = !!base.cspReportOnly;
+    return async (ctx, next) => {
+        try {
+            if (base.hsts)
+                setHeader(ctx, "Strict-Transport-Security", hstsHeader);
+            setHeader(ctx, "X-Frame-Options", frameHeader);
+            setHeader(ctx, "X-Content-Type-Options", noSniffHeader);
+            setHeader(ctx, "X-XSS-Protection", xssHeader);
+            setHeader(ctx, "Referrer-Policy", referrerHeader);
+            if (permissionsHeader)
+                setHeader(ctx, "Permissions-Policy", permissionsHeader);
+            if (cspNeedsNonce) {
+                const nonce = crypto_1.default.randomBytes(12).toString("base64");
+                let cspHeader = cspStatic || `default-src 'self'; script-src 'self' 'nonce-${nonce}'`;
+                if (cspReportOnly)
+                    setHeader(ctx, "Content-Security-Policy-Report-Only", cspHeader);
+                else
+                    setHeader(ctx, "Content-Security-Policy", cspHeader);
+                ctx.cspNonce = nonce;
+            }
+            else if (cspStatic) {
+                if (cspReportOnly)
+                    setHeader(ctx, "Content-Security-Policy-Report-Only", cspStatic);
+                else
+                    setHeader(ctx, "Content-Security-Policy", cspStatic);
+            }
+            return await next();
+        }
+        catch {
+            return await next();
+        }
+    };
+};
+exports.secureHeaders = secureHeaders;

package/cjs/middleware/secure-headers.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secureHeaders = void 0;
+const index_js_1 = require("../helper/index.js");
+const joinSrc = (v) => typeof v === "string" ? v : v.join(" ");
+const buildCSPString = (cspObj) => {
+    const parts = [];
+    for (const key in cspObj)
+        parts.push(`${key} ${joinSrc(cspObj[key])}`);
+    return parts.join("; ");
+};
+const secureHeaders = (userOpts = {}) => {
+    const defaultPresets = {
+        strict: {
+            preset: "strict",
+            hsts: { maxAge: 63072000, includeSubDomains: true, preload: true },
+            frameGuard: "DENY",
+            noSniff: true,
+            xssProtection: true,
+            referrerPolicy: "strict-origin-when-cross-origin",
+            permissionsPolicy: "geolocation=(), microphone=(), camera=(), usb=()",
+            csp: {
+                "default-src": ["'self'"],
+                "script-src": ["'self'"],
+                "style-src": ["'self'", "'unsafe-inline'"],
+                "img-src": ["'self'", "data:", "blob:"],
+                "font-src": ["'self'"],
+                "connect-src": ["'self'"],
+                "object-src": ["'none'"],
+                "frame-ancestors": ["'none'"],
+            },
+            cspReportOnly: false,
+        },
+        balanced: {
+            preset: "balanced",
+            hsts: { maxAge: 31536000, includeSubDomains: true, preload: true },
+            frameGuard: "SAMEORIGIN",
+            noSniff: true,
+            xssProtection: true,
+            referrerPolicy: "no-referrer-when-downgrade",
+            permissionsPolicy: "geolocation=(), microphone=()",
+            csp: {
+                "default-src": ["'self'"],
+                "script-src": ["'self'", "https://cdn.jsdelivr.net"],
+                "style-src": [
+                    "'self'",
+                    "'unsafe-inline'",
+                    "https://fonts.googleapis.com",
+                ],
+                "img-src": ["'self'", "data:", "https://images.example.com"],
+                "connect-src": ["'self'", "https://api.example.com"],
+            },
+            cspReportOnly: true,
+        },
+        dev: {
+            preset: "dev",
+            hsts: undefined,
+            frameGuard: "SAMEORIGIN",
+            noSniff: false,
+            xssProtection: false,
+            referrerPolicy: "no-referrer",
+            permissionsPolicy: "",
+            csp: {
+                "default-src": [
+                    "'self'",
+                    "'unsafe-inline'",
+                    "'unsafe-eval'",
+                    "http://localhost:3000",
+                ],
+                "img-src": ["'self'", "data:", "blob:"],
+            },
+            cspReportOnly: true,
+        },
+    };
+    const preset = userOpts.preset ?? "balanced";
+    const base = {
+        ...(defaultPresets[preset] || defaultPresets.balanced),
+        ...userOpts,
+    };
+    const frameHeader = base.frameGuard || "SAMEORIGIN";
+    const xssHeader = base.xssProtection ? "1; mode=block" : "0";
+    const noSniffHeader = base.noSniff ? "nosniff" : "";
+    const permissionsHeader = base.permissionsPolicy || "";
+    const referrerHeader = base.referrerPolicy || "no-referrer";
+    const hstsParts = [`max-age=${base.hsts?.maxAge || 31536000}`];
+    if (base.hsts?.includeSubDomains)
+        hstsParts.push("includeSubDomains");
+    if (base.hsts?.preload)
+        hstsParts.push("preload");
+    const hstsHeader = hstsParts.join("; ");
+    let cspStatic = null;
+    let cspNeedsNonce = !!base.cspUseNonce;
+    if (typeof base.csp === "string")
+        cspStatic = base.csp;
+    else if (base.csp)
+        cspStatic = buildCSPString(base.csp);
+    const cspReportOnly = !!base.cspReportOnly;
+    const ultraFast = !!base.ultraFastMode;
+    if (cspNeedsNonce && ultraFast) {
+        index_js_1.GlobalConfig.debugging.warn("secureHeaders: ultraFastMode disables CSP nonce support. Nonce will not be used.");
+    }
+    if (ultraFast)
+        cspNeedsNonce = false;
+    return async (ctx, next) => {
+        try {
+            if (base.hsts) {
+                const proto = (ctx.req?.header("x-forwarded-proto") || "").toString();
+                if (!base.hsts.hstsOnlyOnHttps || proto.includes("https")) {
+                    ctx.headers.set("Strict-Transport-Security", hstsHeader);
+                }
+            }
+            ctx.headers.set("X-Frame-Options", frameHeader);
+            ctx.headers.set("X-Content-Type-Options", noSniffHeader);
+            ctx.headers.set("X-XSS-Protection", xssHeader);
+            ctx.headers.set("Referrer-Policy", referrerHeader);
+            if (permissionsHeader)
+                ctx.headers.set("Permissions-Policy", permissionsHeader);
+            if (cspNeedsNonce) {
+                const nonce = (0, index_js_1.generateRandomBase64)();
+                let cspHeader = cspStatic;
+                if (!cspHeader) {
+                    cspHeader = `default-src 'self'; script-src 'self' 'nonce-${nonce}'`;
+                }
+                if (typeof base.csp === "object") {
+                    const idx = cspHeader.indexOf("script-src");
+                    if (idx >= 0) {
+                        const parts = [];
+                        parts.push(cspHeader.slice(0, idx + 10));
+                        parts.push(" 'nonce-" + nonce + "'");
+                        parts.push(cspHeader.slice(idx + 10));
+                        cspHeader = parts.join("");
+                    }
+                    else {
+                        cspHeader += "; script-src 'self' 'nonce-" + nonce + "'";
+                    }
+                }
+                ctx.cspNonce = nonce;
+                if (cspReportOnly)
+                    ctx.headers.set("Content-Security-Policy-Report-Only", cspHeader);
+                else
+                    ctx.headers.set("Content-Security-Policy", cspHeader);
+            }
+            else if (cspStatic) {
+                if (cspReportOnly)
+                    ctx.headers.set("Content-Security-Policy-Report-Only", cspStatic);
+                else
+                    ctx.headers.set("Content-Security-Policy", cspStatic);
+            }
+            return await next();
+        }
+        catch (err) {
+            console.error("secureHeaders middleware error", err);
+            return await next();
+        }
+    };
+};
+exports.secureHeaders = secureHeaders;

package/cjs/middleware/{xssProtection.js → xss-protection.js}

@@ -1,26 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.xssProtection = void 0;
-const config_js_1 = require("../core/config.js");
+exports.xssProtection = exports.default = void 0;
 const xssProtection = (options = {}) => {
     const { enabled = true, mode = "block", fallbackCSP = "default-src 'self'; script-src 'self';", } = options;
     return async function xssProtection(ctx, next) {
         const isEnabled = typeof enabled === "function" ? enabled(ctx) : enabled;
         if (!isEnabled) {
-            config_js_1.GlobalConfig.debugging.warn("🟠 XSS protection is disabled.");
             return await next();
         }
         const xssHeaderValue = mode === "block" ? "1; mode=block" : "1";
-        ctx.headers.set("X-XSS-Protection", xssHeaderValue);
-        config_js_1.GlobalConfig.debugging.warn(`🟢 X-XSS-Protection set to: ${xssHeaderValue}`);
+        ctx.setHeader("X-XSS-Protection", xssHeaderValue);
         if (fallbackCSP) {
-            const existingCSP = ctx.req.headers.get("Content-Security-Policy");
+            const existingCSP = ctx.req.header("content-security-policy");
             if (!existingCSP) {
-                ctx.headers.set("Content-Security-Policy", fallbackCSP);
-                config_js_1.GlobalConfig.debugging.warn(`🟣 Fallback CSP set to: ${fallbackCSP}`);
+                ctx.setHeader("Content-Security-Policy", fallbackCSP);
             }
         }
         return await next();
     };
 };
+exports.default = xssProtection;
 exports.xssProtection = xssProtection;

package/cjs/node/env.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadEnv = loadEnv;
-const node_fs_1 = require("node:fs");
-const environment_js_1 = require("../core/environment.js");
+const fs_1 = require("fs");
+const error_js_1 = require("../core/error.js");
 const colors_js_1 = require("../utils/colors.js");
+const runtime_js_1 = require("../utils/runtime.js");
 function parseEnvFile(filePath, result) {
     try {
-        let runtime = environment_js_1.Environment.getEnvironment;
-        if (runtime !== "bun" && runtime !== "node") {
-            throw new Error(`Please use ${(0, colors_js_1.colorText)(`import {loadEnv} from "tezx/${runtime}"`, "bgRed")} environment`);
+        if (runtime_js_1.runtime !== "bun" && runtime_js_1.runtime !== "node") {
+            throw new error_js_1.TezXError(`Please use ${(0, colors_js_1.colorText)(`import {loadEnv} from "tezx/${runtime_js_1.runtime}"`, "bgRed")} environment`);
         }
-        let fileExists = (0, node_fs_1.existsSync)(filePath);
+        let fileExists = (0, fs_1.existsSync)(filePath);
         if (!fileExists) {
             return;
         }
         let fileContent = "";
-        fileContent = (0, node_fs_1.readFileSync)(filePath, "utf8");
+        fileContent = (0, fs_1.readFileSync)(filePath, "utf8");
         const lines = fileContent.split("\n");
         for (const line of lines) {
             const trimmedLine = line.trim();

package/cjs/node/getConnInfo.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnInfo = getConnInfo;
+function getConnInfo() {
+    return (ctx, next) => {
+        let request = ctx.args?.[0];
+        if (request && request.socket) {
+            ctx.req.remoteAddress = {
+                family: request.socket.remoteFamily,
+                address: request.socket.remoteAddress,
+                port: request.socket.remotePort,
+            };
+        }
+        return next();
+    };
+}

package/cjs/node/index.js

@@ -1,24 +1,23 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const adapter_js_1 = require("./adapter.js");
+exports.mountTezXOnNode = exports.loadEnv = exports.toWebRequest = exports.getConnInfo = exports.upgradeWebSocket = exports.serveStatic = void 0;
 const env_js_1 = require("./env.js");
-__exportStar(require("./adapter.js"), exports);
-__exportStar(require("./env.js"), exports);
+Object.defineProperty(exports, "loadEnv", { enumerable: true, get: function () { return env_js_1.loadEnv; } });
+const getConnInfo_js_1 = require("./getConnInfo.js");
+Object.defineProperty(exports, "getConnInfo", { enumerable: true, get: function () { return getConnInfo_js_1.getConnInfo; } });
+const mount_node_js_1 = require("./mount-node.js");
+Object.defineProperty(exports, "mountTezXOnNode", { enumerable: true, get: function () { return mount_node_js_1.mountTezXOnNode; } });
+const serveStatic_js_1 = require("./serveStatic.js");
+Object.defineProperty(exports, "serveStatic", { enumerable: true, get: function () { return serveStatic_js_1.serveStatic; } });
+const toWebRequest_js_1 = require("./toWebRequest.js");
+Object.defineProperty(exports, "toWebRequest", { enumerable: true, get: function () { return toWebRequest_js_1.toWebRequest; } });
+const ws_js_1 = require("./ws.js");
+Object.defineProperty(exports, "upgradeWebSocket", { enumerable: true, get: function () { return ws_js_1.upgradeWebSocket; } });
 exports.default = {
-    nodeAdapter: adapter_js_1.nodeAdapter,
+    serveStatic: serveStatic_js_1.serveStatic,
+    upgradeWebSocket: ws_js_1.upgradeWebSocket,
+    mountTezXOnNode: mount_node_js_1.mountTezXOnNode,
+    toWebRequest: toWebRequest_js_1.toWebRequest,
+    getConnInfo: getConnInfo_js_1.getConnInfo,
     loadEnv: env_js_1.loadEnv,
 };