tezx 4.0.2 → 4.0.4

package/helper/index.d.ts

@@ -1,3 +1,4 @@
+import { Ctx, NetAddr } from "../types/index.js";
 import { useFormData } from "./formData.js";
 import { generateID, generateRandomBase64, generateUUID } from "./generateID.js";
 export { useFormData, generateID, generateRandomBase64, generateUUID };
@@ -8,3 +9,17 @@ declare const _default: {
     generateUUID: typeof generateUUID;
 };
 export default _default;
+/**
+ * Retrieves remote connection details of the client from the Bun server context.
+ *
+ * This function returns network address information such as transport protocol,
+ * address family, IP/hostname, and port.
+ *
+ * @param {Ctx} ctx - The request context containing the Bun server and raw request.
+ * @returns {NetAddr} Object containing client connection details.
+ *
+ * @example
+ * const conn = getConnInfo(ctx);
+ * console.log(conn.address, conn.port);
+ */
+export declare function getConnInfo(ctx: Ctx): NetAddr;

package/helper/index.js

@@ -5,3 +5,6 @@ export default {
     useFormData,
     generateID, generateRandomBase64, generateUUID
 };
+export function getConnInfo(ctx) {
+    return ctx?.server?.requestIP?.(ctx.rawRequest);
+}

package/index.js

@@ -1,7 +1,7 @@
 import { Router } from "./core/router.js";
 import { TezX } from "./core/server.js";
 export { Router, TezX };
-export let version = "4.0.2";
+export let version = "4.0.4";
 export default {
     Router,
     TezX,

package/middleware/basic-auth.d.ts

@@ -1,4 +1,4 @@
-import { Context } from "../core/context.js";
+import { Context } from "../index.js";
 import { HttpBaseResponse, Middleware } from "../types/index.js";
 /**
  * Options for Basic Authentication middleware.

package/middleware/bearer-auth.d.ts

@@ -1,4 +1,4 @@
-import { Context } from "../core/context.js";
+import { Context } from "../index.js";
 import { HttpBaseResponse, Middleware } from "../types/index.js";
 /**
  * Options for Bearer Authentication middleware.

package/middleware/cache-control.d.ts

@@ -1,4 +1,4 @@
-import { Context } from "../core/context.js";
+import { Context } from "../index.js";
 import { HttpBaseResponse, Middleware } from "../types/index.js";
 export interface CacheRule {
     /** 🎯 Condition to determine if this rule applies */

package/middleware/detect-bot.d.ts

@@ -6,6 +6,7 @@ import { HttpBaseResponse } from "../types/index.js";
 export type DetectBotOptions = {
     /**
      * 🤖 List of known bot-like User-Agent patterns.
+     * Middleware will block requests whose User-Agent matches any of these patterns.
      * @default ["bot", "spider", "crawl", "slurp"]
      * @example
      * botUserAgents: ["bot", "crawler", "indexer"]
@@ -13,40 +14,31 @@ export type DetectBotOptions = {
     botUserAgents?: string[];
     /**
      * ⚖️ Enable rate-limiting based bot detection.
-     * Requires `getConnInfo()` import from TezX runtime.
+     * Middleware will track requests per client and block if exceeding limits.
      * @default false
-     * @example
-     * enableRateLimiting: true
      */
     enableRateLimiting?: boolean;
     /**
-     * 🔑 Client identifier generator function for rate limit
-     * @default (ctx) => `${ctx.req.remoteAddress.address}:${ctx.req.remoteAddress.port}`
+     * 🔑 Function to generate a client identifier for rate-limiting.
+     * By default, it uses the client's IP and port via `getConnInfo`.
      * @example
-     * keyGenerator: (ctx) => ctx.user?.id || ctx.ip // Use user ID if authenticated
+     * keyGenerator: (ctx) => ctx.user?.id || ctx.ip
      */
     keyGenerator?: (ctx: Context) => string;
     /**
      * ⚠️ Maximum allowed requests in the rate-limit window.
-     * Only used when `enableRateLimiting` is true.
+     * Only used if `enableRateLimiting` is true.
      * @default 30
      */
     maxRequests?: number;
     /**
-     * ⏱️ Time window for rate-limiting (in milliseconds).
+     * ⏱️ Time window for rate-limiting in milliseconds.
      * @default 60000 (1 minute)
      */
     windowMs?: number;
     /**
      * 🔄 Custom rate-limit storage implementation.
-     * Allows integration with Redis, Memcached, or in-memory stores.
-     * @default In-memory Map
-     * @example
-     * storage: {
-     *   get: (key) => myRedisClient.get(key),
-     *   set: (key, value) => myRedisClient.set(key, value),
-     *   clearExpired: () => {}
-     * }
+     * Can integrate with Redis, Memcached, or an in-memory store.
      */
     storage?: {
         get: (key: string) => {
@@ -61,54 +53,44 @@ export type DetectBotOptions = {
     };
     /**
      * 🚫 Optional IP blacklist checker.
-     * Should return true if the current request’s IP is banned or suspicious.
+     * Return true to block a specific IP.
      * @default () => false
-     * @example
-     * isBlacklisted: (ctx) => ctx.req.remoteAddress.address === "192.168.0.10"
      */
     isBlacklisted?: (ctx: Context) => boolean | Promise<boolean>;
     /**
      * 🧠 Custom bot detector function.
-     * Use this for advanced heuristics (e.g., suspicious query params or headers).
-     * @example
-     * customBotDetector: (ctx) => ctx.query?.token === "weird"
+     * Return true to block the request based on custom logic.
      */
     customBotDetector?: (ctx: Context) => boolean | Promise<boolean>;
     /**
-     * 🛡️ Action executed when a bot is detected.
-     * Can return a custom HTTP response (e.g., JSON, HTML, or redirect).
+     * 🛡️ Callback executed when a bot is detected.
+     * Can return a custom HTTP response (JSON, HTML, redirect, etc.).
      * @default Responds with 403 and JSON error.
-     * @example
-     * onBotDetected: (ctx, reason) => ctx.status(403).json({ error: `Blocked: ${reason}` })
      */
     onBotDetected?: (ctx: Context, reason: string) => HttpBaseResponse;
 };
 /**
  * 🤖 Smart Bot Detection Middleware
  *
- * Detects automated or malicious requests using a combination of:
+ * Detects automated or malicious requests using multiple strategies:
  * - User-Agent analysis
- * - IP blacklisting
- * - Rate limiting
- * - Custom detection logic
- *
- * 🧩 Supports:
- * - Bun (uses precompiled RegExp for speed)
- * - Node.js / Deno (optimized `includes()` loop)
+ * - IP blacklist
+ * - Rate-limiting per client
+ * - Custom bot detection
  *
- * ⚙️ Requirements (for rate limiting):
- * You must import `getConnInfo` from your runtime adapter:
+ * The client identity for rate-limiting is determined via `getConnInfo(ctx)`,
+ * which returns the connection info:
  * ```ts
- * import { getConnInfo } from "tezx/bun";
- * // or
- * import { getConnInfo } from "tezx/node";
- * // or
- * import { getConnInfo } from "tezx/deno";
+ * {
+ *   address: string;   // IP address of the client
+ *   port?: number;     // Port number of the client
+ *   transport?: string;// Transport protocol (tcp, udp)
+ * }
  * ```
  *
  * 📦 Example Usage:
  * ```ts
- * import { detectBot } from "tezx/middleware/detectBot";
+ * import { detectBot } from "tezx/middleware";
  *
  * app.use(detectBot({
  *   enableRateLimiting: true,

package/middleware/detect-bot.js

@@ -1,3 +1,4 @@
+import { getConnInfo } from "../helper/index.js";
 import { createRateLimitDefaultStorage, isRateLimit } from "../utils/rateLimit.js";
 export const detectBot = (opts = {}) => {
     const botUAs = opts.botUserAgents || ["bot", "spider", "crawl", "slurp"];
@@ -5,7 +6,7 @@ export const detectBot = (opts = {}) => {
     const botRegex = new RegExp(botUAs.join("|"), "i");
     checkBot = (ua) => botRegex.test(ua);
     const keyGenerator = opts.keyGenerator ?? ((ctx) => {
-        const addr = ctx.req.remoteAddress;
+        const addr = getConnInfo(ctx);
         return addr ? `${addr.address}:${addr.port}` : "unknown";
     });
     const maxReq = opts.maxRequests || 30;

package/middleware/index.d.ts

@@ -4,7 +4,6 @@ export * from "./cache-control.js";
 export * from "./cors.js";
 export * from "./detect-bot.js";
 export * from "./etag.js";
-export * from "./getConnInfo.js";
 export * from "./i18n.js";
 export * from "./logger.js";
 export * from "./pagination.js";

package/middleware/index.js

@@ -4,7 +4,6 @@ export * from "./cache-control.js";
 export * from "./cors.js";
 export * from "./detect-bot.js";
 export * from "./etag.js";
-export * from "./getConnInfo.js";
 export * from "./i18n.js";
 export * from "./logger.js";
 export * from "./pagination.js";

package/middleware/pagination.js

@@ -39,8 +39,9 @@ const paginationHandler = (options = {}) => {
                 pagination,
             };
             ctx.body = body;
-            if (next) {
-                return await next();
+            let res = await next();
+            if (res) {
+                return res;
             }
             return ctx.json(body);
         }

package/middleware/rate-limiter.d.ts

@@ -1,4 +1,4 @@
-import { Context } from "../core/context.js";
+import { Context } from "../index.js";
 import { HttpBaseResponse, Middleware } from "../types/index.js";
 export type RateLimiterOptions = {
     /**
@@ -14,15 +14,16 @@ export type RateLimiterOptions = {
      */
     windowMs: number;
     /**
-     * 🔑 Client identifier generator function
-     * @default (ctx) => `${ctx.req.remoteAddress.address}:${ctx.req.remoteAddress.port}`
+     * 🔑 Function to generate a client identifier for rate-limiting.
+     * By default, it uses `X-Forwarded-For`, `Client-IP`, or `getConnInfo(ctx)`.
      * @example
-     * keyGenerator: (ctx) => ctx.user?.id || ctx.ip // Use user ID if authenticated
+     * keyGenerator: (ctx) => ctx.user?.id || ctx.ip
      */
     keyGenerator?: (ctx: Context) => string;
     /**
-     * 🔄 Custom cache storage implementation (e.g., using `Map`, `Redis`, etc.).
-     * By default, it uses a `Map<string, { count: number; resetTime: number }>`.
+     * 🔄 Custom cache/storage implementation.
+     * Must provide `get`, `set`, and `clearExpired` methods.
+     * @default In-memory Map via `createRateLimitDefaultStorage()`
      */
     storage?: {
         get: (key: string) => {
@@ -36,42 +37,39 @@ export type RateLimiterOptions = {
         clearExpired: () => void;
     };
     /**
-     * 🛑 Custom rate limit exceeded handler
-     * @default Sends 429 status with Retry-After header
-     * @example
-     * onError: (ctx, retryAfter) => {
-     *   ctx.status = 429;
-     *   throw new Error( `Rate limit exceeded. Try again in ${retryAfter} seconds.`);
-     * }
+     * 🛑 Custom handler when rate limit is exceeded.
+     * @default Throws 429 status with Retry-After header
      */
     onError?: (ctx: Context, retryAfter: number, error: Error) => HttpBaseResponse;
 };
 /**
- * 🚦 Rate limiting middleware for request throttling
+ * 🚦 Rate Limiter Middleware
+ *
+ * Throttles requests per client based on a sliding window.
+ * Supports custom client identification and storage backends.
+ *
+ * Client IP detection uses (in order):
+ * 1. `X-Forwarded-For` header
+ * 2. `Client-IP` header
+ * 3. `getConnInfo(ctx)` fallback
  *
- * Enforces maximum request limits per client with sliding window.
- * Currently supports in-memory storage only (Redis coming soon).
- * @requires
- *  *
-```ts
-  import { getConnInfo } from "tezx/middleware";
-```
- * @param {RateLimiterOptions} options - Configuration
- * @returns {Middleware} Middleware function
+ * ```ts
+ * import { getConnInfo } from "tezx/helper";
+ * ```
+ *
+ * @param options RateLimiterOptions
+ * @returns Middleware function
  *
  * @example
  * // Basic rate limiting (100 requests/minute)
- * app.use(rateLimiter({
- *   maxRequests: 100,
- *   windowMs: 60_000
- * }));
+ * app.use(rateLimiter({ maxRequests: 100, windowMs: 60_000 }));
  *
  * // Custom client identification
  * app.use(rateLimiter({
  *   maxRequests: 10,
  *   windowMs: 10_000,
- *   keyGenerator: (ctx) => ctx.user?.id || ctx.remoteAddress.address
+ *   keyGenerator: (ctx) => ctx.user?.id
  * }));
  */
 declare const rateLimiter: <T extends Record<string, any> = {}, Path extends string = any>(options: RateLimiterOptions) => Middleware<T, Path>;
-export { rateLimiter, rateLimiter as default };
+export { rateLimiter as default, rateLimiter };

package/middleware/rate-limiter.js

@@ -1,3 +1,4 @@
+import { getConnInfo } from "../helper/index.js";
 import { createRateLimitDefaultStorage, isRateLimit } from "../utils/rateLimit.js";
 const rateLimiter = (options) => {
     const { maxRequests, windowMs, keyGenerator = (ctx) => {
@@ -9,9 +10,8 @@ const rateLimiter = (options) => {
         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}`;
+        const { port, address } = getConnInfo(ctx) ?? {};
+        return `${address}:${port}`;
     }, storage = createRateLimitDefaultStorage(), onError = (ctx, retryAfter, error) => {
         ctx.status(429);
         throw new Error(`Rate limit exceeded. Try again in ${retryAfter} seconds.`);
@@ -30,4 +30,4 @@ const rateLimiter = (options) => {
         return await next();
     };
 };
-export { rateLimiter, rateLimiter as default };
+export { rateLimiter as default, rateLimiter };

package/middleware/xss-protection.d.ts

@@ -1,4 +1,4 @@
-import { Context } from "../core/context.js";
+import { Context } from "../index.js";
 import { Middleware } from "../types/index.js";
 export type XSSProtectionOptions = {
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tezx",
-  "version": "4.0.2",
+  "version": "4.0.4",
   "description": "TezX is a modern, ultra-lightweight, and high-performance JavaScript framework built specifically for Bun. It provides a minimal yet powerful API, seamless environment management, and a high-concurrency HTTP engine for building fast, scalable web applications.",
   "type": "module",
   "main": "cjs/index.js",

package/types/index.d.ts

@@ -115,7 +115,7 @@ export interface CookieOptions {
     /** Controls cross-site request behavior. One of "Strict", "Lax", or "None". */
     sameSite?: "Strict" | "Lax" | "None";
 }
-import { Context } from "../core/context.js";
+import { BaseContext, Context } from "../index.js";
 import { RequestHeader, ResponseHeader } from "./headers.js";
 /**
  * Options to customize static file serving behavior.
@@ -236,7 +236,7 @@ export type HttpBaseResponse = Response | Promise<Response>;
  * @template T - Custom environment or app-level data.
  * @template Path - Type of the route path (optional).
  */
-export type Ctx<T extends Record<string, any> = {}, Path extends string = any> = Context<Path> & T & {
+export type Ctx<T extends Record<string, any> = {}, Path extends string = any> = BaseContext<Path> & T & {
     [key: string]: any;
     /**
      * Response body, can be string, Buffer, stream, etc. like context propagation.
@@ -311,7 +311,11 @@ export interface FormDataOptions {
  */
 type TransportType = "tcp" | "udp" | "unix" | "pipe" | "unixpacket";
 /**
- * A normalized network address description.
+ * Remote address details of the connected client.
+ * @property {string} [transport] - Transport protocol (e.g., "tcp", "udp").
+ * @property {"IPv4" | "IPv6" | "Unix"} [family] - Address family.
+ * @property {string} [hostname] - Hostname or IP address.
+ * @property {number} [port] - Port number.
  */
 export type NetAddr = {
     /** Transport protocol used by the connection. */

package/utils/mimeTypes.d.ts

@@ -1,4 +1,117 @@
 export declare const mimeTypes: {
-    [key: string]: string;
+    readonly html: "text/html";
+    readonly htm: "text/html";
+    readonly css: "text/css";
+    readonly js: "text/javascript";
+    readonly mjs: "text/javascript";
+    readonly json: "application/json";
+    readonly xml: "application/xml";
+    readonly txt: "text/plain";
+    readonly md: "text/markdown";
+    readonly csv: "text/csv";
+    readonly tsv: "text/tab-separated-values";
+    readonly rtf: "application/rtf";
+    readonly markdown: "text/markdown";
+    readonly jsx: "text/javascript";
+    readonly ts: "text/typescript";
+    readonly tsx: "text/typescript";
+    readonly jsonld: "application/ld+json";
+    readonly png: "image/png";
+    readonly jpg: "image/jpeg";
+    readonly jpeg: "image/jpeg";
+    readonly gif: "image/gif";
+    readonly svg: "image/svg+xml";
+    readonly webp: "image/webp";
+    readonly ico: "image/x-icon";
+    readonly bmp: "image/bmp";
+    readonly tiff: "image/tiff";
+    readonly psd: "image/vnd.adobe.photoshop";
+    readonly tif: "image/tiff";
+    readonly avif: "image/avif";
+    readonly woff: "font/woff";
+    readonly woff2: "font/woff2";
+    readonly ttf: "font/ttf";
+    readonly otf: "font/otf";
+    readonly eot: "application/vnd.ms-fontobject";
+    readonly mp4: "video/mp4";
+    readonly webm: "video/webm";
+    readonly ogg: "video/ogg";
+    readonly mov: "video/quicktime";
+    readonly avi: "video/x-msvideo";
+    readonly wmv: "video/x-ms-wmv";
+    readonly flv: "video/x-flv";
+    readonly "3gp": "video/3gpp";
+    readonly mkv: "video/x-matroska";
+    readonly mpeg: "video/mpeg";
+    readonly mpg: "video/mpeg";
+    readonly mp3: "audio/mpeg";
+    readonly wav: "audio/wav";
+    readonly aac: "audio/aac";
+    readonly flac: "audio/flac";
+    readonly m4a: "audio/mp4";
+    readonly mid: "audio/midi";
+    readonly midi: "audio/midi";
+    readonly weba: "audio/webm";
+    readonly pdf: "application/pdf";
+    readonly odp: "application/vnd.oasis.opendocument.presentation";
+    readonly zip: "application/zip";
+    readonly gz: "application/gzip";
+    readonly tar: "application/x-tar";
+    readonly rar: "application/x-rar-compressed";
+    readonly _7z: "application/x-7z-compressed";
+    readonly bz2: "application/x-bzip2";
+    readonly "7z": "application/x-7z-compressed";
+    readonly doc: "application/msword";
+    readonly docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    readonly xls: "application/vnd.ms-excel";
+    readonly xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    readonly ppt: "application/vnd.ms-powerpoint";
+    readonly pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+    readonly odt: "application/vnd.oasis.opendocument.text";
+    readonly ods: "application/vnd.oasis.opendocument.spreadsheet";
+    readonly wasm: "application/wasm";
+    readonly map: "application/json";
+    readonly yaml: "application/yaml";
+    readonly yml: "application/yaml";
+    readonly proto: "text/plain";
+    readonly graphql: "application/graphql";
+    readonly pem: "application/x-pem-file";
+    readonly cer: "application/pkix-cert";
+    readonly crt: "application/x-x509-ca-cert";
+    readonly key: "application/x-pem-file";
+    readonly pfx: "application/x-pkcs12";
+    readonly glb: "model/gltf-binary";
+    readonly gltf: "model/gltf+json";
+    readonly obj: "model/obj";
+    readonly stl: "model/stl";
+    readonly usdz: "model/vnd.usdz+zip";
+    readonly exe: "application/x-msdownload";
+    readonly dmg: "application/x-apple-diskimage";
+    readonly deb: "application/x-debian-package";
+    readonly rpm: "application/x-redhat-package-manager";
+    readonly apk: "application/vnd.android.package-archive";
+    readonly bin: "application/octet-stream";
+    readonly iso: "application/octet-stream";
+    readonly webmanifest: "application/manifest+json";
+    readonly ics: "text/calendar";
+    readonly vcf: "text/vcard";
+    readonly warc: "application/warc";
+    readonly atom: "application/atom+xml";
+    readonly rss: "application/rss+xml";
+    readonly dll: "application/x-msdownload";
+    readonly sh: "application/x-sh";
+    readonly py: "text/x-python";
+    readonly rb: "text/x-ruby";
+    readonly pl: "text/x-perl";
+    readonly php: "application/x-httpd-php";
+    readonly torrent: "application/x-bittorrent";
+    readonly ipa: "application/vnd.iphone";
+    readonly eps: "application/postscript";
+    readonly ps: "application/postscript";
+    readonly ai: "application/postscript";
+    readonly swf: "application/x-shockwave-flash";
+    readonly jar: "application/java-archive";
+    readonly gcode: "text/x.gcode";
 };
+export type ContentType = (typeof mimeTypes[keyof typeof mimeTypes]) | "application/octet-stream" | (string & {});
 export declare const defaultMimeType = "application/octet-stream";

package/utils/mimeTypes.js

@@ -12,6 +12,10 @@ export const mimeTypes = {
     tsv: "text/tab-separated-values",
     rtf: "application/rtf",
     markdown: "text/markdown",
+    jsx: "text/javascript",
+    ts: "text/typescript",
+    tsx: "text/typescript",
+    jsonld: "application/ld+json",
     png: "image/png",
     jpg: "image/jpeg",
     jpeg: "image/jpeg",
@@ -22,6 +26,13 @@ export const mimeTypes = {
     bmp: "image/bmp",
     tiff: "image/tiff",
     psd: "image/vnd.adobe.photoshop",
+    tif: "image/tiff",
+    avif: "image/avif",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf",
+    otf: "font/otf",
+    eot: "application/vnd.ms-fontobject",
     mp4: "video/mp4",
     webm: "video/webm",
     ogg: "video/ogg",
@@ -30,6 +41,9 @@ export const mimeTypes = {
     wmv: "video/x-ms-wmv",
     flv: "video/x-flv",
     "3gp": "video/3gpp",
+    mkv: "video/x-matroska",
+    mpeg: "video/mpeg",
+    mpg: "video/mpeg",
     mp3: "audio/mpeg",
     wav: "audio/wav",
     aac: "audio/aac",
@@ -37,11 +51,7 @@ export const mimeTypes = {
     m4a: "audio/mp4",
     mid: "audio/midi",
     midi: "audio/midi",
-    woff: "font/woff",
-    woff2: "font/woff2",
-    ttf: "font/ttf",
-    otf: "font/otf",
-    eot: "application/vnd.ms-fontobject",
+    weba: "audio/webm",
     pdf: "application/pdf",
     odp: "application/vnd.oasis.opendocument.presentation",
     zip: "application/zip",
@@ -80,6 +90,8 @@ export const mimeTypes = {
     deb: "application/x-debian-package",
     rpm: "application/x-redhat-package-manager",
     apk: "application/vnd.android.package-archive",
+    bin: "application/octet-stream",
+    iso: "application/octet-stream",
     webmanifest: "application/manifest+json",
     ics: "text/calendar",
     vcf: "text/vcard",

package/utils/response.d.ts

@@ -1,4 +1,4 @@
-import { Context } from "../core/context.js";
+import { Context } from "../index.js";
 import { HttpBaseResponse, ResponseHeaders } from "../types/index.js";
 export declare let notFoundResponse: (ctx: Context) => HttpBaseResponse;
 export declare function mergeHeaders(existing?: Headers, init?: ResponseHeaders): Headers;

package/cjs/middleware/getConnInfo.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConnInfo = getConnInfo;
-function getConnInfo() {
-    return (ctx, next) => {
-        let server = ctx.server;
-        if (server && server.requestIP) {
-            ctx.req.remoteAddress = server.requestIP(ctx.rawRequest);
-        }
-        return next();
-    };
-}
-exports.default = getConnInfo;

package/middleware/getConnInfo.d.ts

@@ -1,22 +0,0 @@
-import { Middleware } from "../types/index.js";
-/**
- * Middleware to extract and inject connection information into the request context.
- *
- * This middleware reads the socket's remote address information (like IP, port, and family)
- * from the request object and attaches it to `ctx.req.remoteAddress`.
- *
- * @returns {Middleware<any>} The middleware function that sets `ctx.req.remoteAddress`.
- *
- * @example
- * import { getConnInfo } from "tezx/middleware";
- *
- * app.use(getConnInfo());
- *
- * // Access later in route handler:
- * router.get("/", (ctx) => {
- *   const ip = ctx.req.remoteAddress?.address;
- *   return new Response(`Your IP: ${ip}`);
- * });
- */
-export declare function getConnInfo<T extends Record<string, any> = {}, Path extends string = any>(): Middleware<T, Path>;
-export default getConnInfo;

package/middleware/getConnInfo.js

@@ -1,10 +0,0 @@
-export function getConnInfo() {
-    return (ctx, next) => {
-        let server = ctx.server;
-        if (server && server.requestIP) {
-            ctx.req.remoteAddress = server.requestIP(ctx.rawRequest);
-        }
-        return next();
-    };
-}
-export default getConnInfo;