Reduce complexity and dependencies

Author: gaurishhs

README.md

@@ -10,7 +10,7 @@ Please consider starring the repository to show your ❤️ and support.
 ## Installation
 
 Requires Bun v1.0.4 or above.
-Requires Elysia v1.0.9 or above. 
+Requires Elysia v1.0.9 or above.
 For older elysia versions please install v0.0.7 of this package
 
 ```bash
@@ -29,14 +29,17 @@ This plugin adds a `ip` property to the context object. It contains the client i
 import { Elysia } from "elysia";
 import { ip } from "elysia-ip";
 
-new Elysia().use(ip()).get("/", ({ ip }) => ip).listen(3000);
+new Elysia()
+  .use(ip())
+  .get("/", ({ ip }) => ip)
+  .listen(3000);
 ```
 
 ### How does it work?
 
 For Bun runtime, We use `server.requestIP` introduced in Bun v1.0.4 to get the client ip address and early return it.
 
-It relies on headers for runtimes other than Bun. 
+It relies on headers for runtimes other than Bun.
 Cloudflare and other providers send back specific headers, containing the IP address. For example `CF-Connecting-IP` for Cloudflare and `Fastly-Client-IP` for Fastly.
 
 We also add support for `X-Forwarded-For` header (de-facto standard header) and other various headers.
@@ -63,16 +66,22 @@ You can even specify your own headers if you want to as following
 import { Elysia } from "elysia";
 import { ip } from "elysia-ip";
 
-new Elysia().use(ip({ checkHeaders: ["X-Forwarded-For", "X-Real-IP"] })).get("/", ({ ip }) => ip).listen(3000);
+new Elysia()
+  .use(ip({ checkHeaders: ["X-Forwarded-For", "X-Real-IP"] }))
+  .get("/", ({ ip }) => ip)
+  .listen(3000);
 ```
 
-or 
+or
 
 ```ts
 import { Elysia } from "elysia";
 import { ip } from "elysia-ip";
 
-new Elysia().use(ip({ checkHeaders: "X-Forwarded-For" })).get("/", ({ ip }) => ip).listen(3000);
+new Elysia()
+  .use(ip({ checkHeaders: "X-Forwarded-For" }))
+  .get("/", ({ ip }) => ip)
+  .listen(3000);
 ```
 
 You can also switch to Headers only mode by setting `headersOnly` to `true`. This will only check headers and not the `server.requestIP` property.
@@ -81,11 +90,20 @@ You can also switch to Headers only mode by setting `headersOnly` to `true`. Thi
 import { Elysia } from "elysia";
 import { ip } from "elysia-ip";
 
-new Elysia().use(ip({ headersOnly: true })).get("/", ({ ip }) => ip).listen(3000);
+new Elysia()
+  .use(ip({ headersOnly: true }))
+  .get("/", ({ ip }) => ip)
+  .listen(3000);
 ```
 
+## Debugging
+
+Please use run the command setting environment variable `NODE_DEBUG` to either `*` or `elysia-ip`
+
 ## License
+
 MIT
 
 ## Author
+
 Copyright (c) 2023 Gaurish Sethia, All Rights Reserved.

package.json

@@ -21,13 +21,9 @@
   "types": "./dist/index.d.ts",
   "bugs": "https://github.com/gaurishhs/elysia-ip/issues",
   "homepage": "https://github.com/gaurishhs/elysia-ip",
-  "keywords": [
-    "elysia",
-    "typescript",
-    "ip"
-  ],
+  "keywords": ["elysia", "typescript", "ip"],
   "scripts": {
-    "dev": "DEBUG=* bun run --hot example/basic.ts",
+    "dev": "NODE_DEBUG=* bun run --hot example/basic.ts",
     "build": "rm -rf dist && tsc --project tsconfig.esm.json",
     "lint": "eslint . --ext .ts"
   },
@@ -43,8 +39,5 @@
   },
   "peerDependencies": {
     "elysia": ">= 1.0.9"
-  },
-  "dependencies": {
-    "debug": "^4.3.4"
   }
 }

src/index.ts

@@ -1,5 +1,5 @@
-export { getIP } from "./services/getip"
-export { plugin as ip } from "./services/plugin"
+export { getIP } from "./services/getip";
+export { plugin as ip } from "./services/plugin";
 
-export { defaultOptions, headersToCheck } from "./constants"
-export type { IPHeaders, Options, InjectServer} from "./types"
+export { defaultOptions, headersToCheck } from "./constants";
+export type { IPHeaders, Options, InjectServer } from "./types";

src/services/debug.ts

@@ -0,0 +1,5 @@
+import { debuglog } from "node:util";
+
+export const debug = (message: string) => {
+  debuglog("elysia-ip")(message);
+};

src/services/getip.ts

@@ -1,39 +1,39 @@
-import { headersToCheck } from "../constants"
-import { IPHeaders } from "../types"
-import { logger } from "./logger"
+import { headersToCheck } from "../constants";
+import { IPHeaders } from "../types";
+import { debug } from "./debug";
 
 export const getIP = (
   headers: Headers,
   checkHeaders: IPHeaders[] = headersToCheck,
 ) => {
   if (typeof checkHeaders === "string" && headers.get(checkHeaders)) {
-    logger("getIP", `Found ip from header ${checkHeaders}`)
-    return headers.get(checkHeaders)
+    debug(`getIP: Found ip from header ${checkHeaders}`);
+    return headers.get(checkHeaders);
   }
 
   // X-Forwarded-For is the de-facto standard header
   if (!checkHeaders && headers.get("x-forwarded-for")) {
-    logger("getIP", "IP From Header x-forwarded-for")
-    return headers.get("x-forwarded-for")?.split(",")[0]
+    debug("getIP: IP From Header x-forwarded-for");
+    return headers.get("x-forwarded-for")?.split(",")[0];
   }
 
   if (!checkHeaders) {
-    logger("getIP", "checkHeaders `false` return `null`")
-    return null
+    debug("getIP: No checkHeaders");
+    return null;
   }
 
-  let clientIP: string | undefined | null = null
+  let clientIP: string | undefined | null = null;
   for (const header of checkHeaders) {
-    clientIP = headers.get(header)
+    clientIP = headers.get(header);
     if (clientIP) {
-      logger("getIP", `Found ip from header ${header}`)
-      break
+      debug(`getIP: Found ip from header ${header}`);
+      break;
     }
   }
 
   if (!clientIP) {
-    logger("getIP", "Failed to get ip from header!")
-    return
+    debug("getIP: Failed to get ip from header!");
+    return;
   }
-  return clientIP
-}
+  return clientIP;
+};

src/services/logger.ts

@@ -1,50 +1,48 @@
-import { Elysia } from "elysia"
-import { getIP } from "./getip"
-import { defaultOptions } from "../constants"
-import { logger } from "./logger"
-
-import type { Options } from "../types"
+import { Elysia } from "elysia";
+import { getIP } from "./getip";
+import { defaultOptions } from "../constants";
+import { debug } from "./debug";
+import type { Options } from "../types";
 
 export const plugin = (userOptions?: Partial<Options>) => (app: Elysia) => {
   const options: Options = {
     ...defaultOptions,
     ...userOptions,
-  }
+  };
 
   return app.use(
     new Elysia({
       name: "elysia-ip",
     }).derive({ as: "global" }, ({ request }): { ip: string } => {
       serverIP: {
         if (!options.headersOnly && globalThis.Bun) {
-          const server = options.injectServer(app)
+          const server = options.injectServer(app);
           if (!server) {
-            logger(
-              "plugin",
-              "Elysia server is not initialized. Make sure to call Elyisa.listen()",
-            )
-            logger("plugin", "use injectServer to inject Server instance")
-            break serverIP
+            debug(
+              "plugin: Elysia server is not initialized. Make sure to call Elyisa.listen()",
+            );
+            debug("plugin: use injectServer to inject Server instance");
+            break serverIP;
           }
 
           if (!server.requestIP) {
-            logger("plugin", "server.requestIP is null")
-            logger("plugin", "Please check server instace")
-            break serverIP
+            debug("plugin: server.requestIP is null");
+            debug("plugin: Please check server instace");
+            break serverIP;
           }
 
-          const socketAddress = server.requestIP(request)
-          logger("plugin", "socketAddress", socketAddress)
+          const socketAddress = server.requestIP(request);
+          debug(`plugin: socketAddress ${JSON.stringify(socketAddress)}`);
           if (!socketAddress) {
-            logger("plugin", "ip from server.requestIP return `null`")
-            break serverIP
+            debug("plugin: ip from server.requestIP return `null`");
+            break serverIP;
           }
-          return { ip: socketAddress.address }
+          return { ip: socketAddress.address };
         }
       }
       return {
         ip: getIP(request.headers, options.checkHeaders) || "",
-      }
+      };
     }),
-  )
-}
+  );
+};