node-ipdox 1.0.0

package/LICENSE.md

@@ -0,0 +1,7 @@
+# [ISC License](https://spdx.org/licenses/ISC)
+
+Copyright (c) 2023, Mikel Calvo <contact@mikelcalvo.net>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+[![NPM version][npm-version-image]][npm-url]
+
+# Node.JS IP Doxxer
+
+IPDox is a simple and efficient IP geolocation library for Node.js. It fetches data from multiple geolocation APIs and provides a unified response. It also includes a caching mechanism to prevent unnecessary requests.
+
+## Installation
+
+```bash
+npm install node-ipdox --save
+```
+
+## Usage
+
+```javascript
+import { IPDox } from "node-ipdox";
+
+const ipdox = new IPDox({ cacheTimeout: 43200000, maxRetries: 10 });
+
+ipdox
+	.doxIP({ ip: "8.8.8.8" })
+	.then(response => console.log(response))
+	.catch(error => console.error(error));
+```
+
+## API
+
+### `new IPDox({ cacheTimeout, maxRetries })`
+
+Creates a new instance of IPDox.
+
+- `cacheTimeout` - The cache timeout in milliseconds (default: 43200000 (12 hours))
+- `maxRetries` - Maximum number of retries if an API request fails (default: 10)
+
+### `ipdox.doxIP({ ip })`
+
+Fetches geolocation data for the specified IP address.
+
+- `ip` - IP address
+
+Returns a Promise that resolves to an `IPDOXResponse` object.
+
+## IPDOXResponse
+
+The `IPDOXResponse` object includes the following properties:
+
+```typescript
+export interface IPDOXResponse {
+	ip: string; // IP address
+	country: string; // Country ISO code
+	city: string; // City name
+	continent: string; // Continent ISO code
+	latitude: number; // Latitude
+	longitude: number; // Longitude
+	zip: string; // Zip code
+	isp: string; // ISP name
+	proxy?: boolean; // Boolean indicating if the IP address is a proxy (might be undefined)
+	isHosting?: boolean; // Boolean indicating if the IP address is a hosting provider (might be undefined)
+	proxyInfo?: {
+		// Proxy information  (might be undefined)
+		isVPN: boolean; // Boolean indicating if the IP address is a VPN (might be undefined)
+		isTOR: boolean; // Boolean indicating if the IP address is a TOR node (might be undefined)
+		isProxy: boolean; // Boolean indicating if the IP address is a proxy (might be undefined)
+	};
+	source: string; // Source API
+}
+```
+
+## Contributing
+
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+## License
+
+This project is licensed under the [ISC License](https://spdx.org/licenses/ISC).
+
+---
+
+[npm-url]: https://npmjs.org/package/node-ipdox
+[npm-version-image]: http://img.shields.io/npm/v/node-ipdox.svg?style=flat

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import _IPDox from "./ipdox";
+/**
+ * Main Class
+ */
+export declare const IPDox: typeof _IPDox;
+/**
+ * Constructor type
+ */
+export { IPDOXConstructor } from "./types/IPDOXConstructor";
+/**
+ * Params type
+ */
+export { IPDOXRequest } from "./types/IPDOXRequest";
+/**
+ * Response type
+ */
+export { IPDOXResponse } from "./types/IPDOXResponse";

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPDox = void 0;
+const ipdox_1 = __importDefault(require("./ipdox"));
+/**
+ * Main Class
+ */
+exports.IPDox = ipdox_1.default;

package/dist/ipdox.d.ts

@@ -0,0 +1,31 @@
+import { IPDOXRequest } from "./types/IPDOXRequest";
+import { IPDOXResponse } from "./types/IPDOXResponse";
+import { IPDOXConstructor } from "./types/IPDOXConstructor";
+declare class IPDox {
+    private cache;
+    private cacheTimeout;
+    private maxRetries;
+    /**
+     * @description Creates an instance of ListSubscribers.
+     * @param {IPDOXConstructor} params - Params of the constructor
+     * @param {number} params.cacheTimeout - The cache timeout in milliseconds (default: 43200000 (12 hours))
+     *
+     *
+     */
+    constructor({ cacheTimeout, maxRetries }: IPDOXConstructor);
+    /**
+     * @description Get all the subscribers of a list
+     * @param {IPDOXRequest} params - Params of the request
+     * @param {string} params.ip - IP address
+     * @returns {Promise<IPDOXResponse>} - Promise of the response
+     * @memberof IPDox
+     */
+    doxIP({ ip }: IPDOXRequest): Promise<IPDOXResponse | undefined>;
+    private selectRandomAPI;
+    private cacheResponse;
+    private fetchIPHyphenAPIDotCom;
+    private fetchFreeIPAPIDotCom;
+    private fetchIPWhoDotIs;
+    private fetchIPAPIDotCo;
+}
+export default IPDox;

package/dist/ipdox.js

@@ -0,0 +1,192 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const apis_1 = require("./utils/apis");
+class IPDox {
+    /**
+     * @description Creates an instance of ListSubscribers.
+     * @param {IPDOXConstructor} params - Params of the constructor
+     * @param {number} params.cacheTimeout - The cache timeout in milliseconds (default: 43200000 (12 hours))
+     *
+     *
+     */
+    constructor({ cacheTimeout = 43200000, maxRetries = 10 }) {
+        this.cache = new Map();
+        this.cacheTimeout = cacheTimeout;
+        this.maxRetries = maxRetries;
+    }
+    /**
+     * @description Get all the subscribers of a list
+     * @param {IPDOXRequest} params - Params of the request
+     * @param {string} params.ip - IP address
+     * @returns {Promise<IPDOXResponse>} - Promise of the response
+     * @memberof IPDox
+     */
+    doxIP({ ip }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check if the IP is already in the cache
+            if (this.cache.has(ip)) {
+                const cachedResponse = this.cache.get(ip);
+                if (cachedResponse) {
+                    return cachedResponse;
+                }
+            }
+            // Select a random API
+            let randomAPI = this.selectRandomAPI();
+            let response = null;
+            let retries = 0;
+            // Fetch data from the API
+            while (!response && retries < this.maxRetries) {
+                try {
+                    switch (randomAPI) {
+                        case apis_1.GeoAPIs.IP_HYPHEN_API_DOT_COM:
+                            response = yield this.fetchIPHyphenAPIDotCom(ip);
+                            break;
+                        case apis_1.GeoAPIs.FREE_IP_API_DOT_COM:
+                            response = yield this.fetchFreeIPAPIDotCom(ip);
+                            break;
+                        case apis_1.GeoAPIs.IPWHO_DOT_IS:
+                            response = yield this.fetchIPWhoDotIs(ip);
+                            break;
+                        case apis_1.GeoAPIs.IPAPI_DOT_CO:
+                            response = yield this.fetchIPAPIDotCo(ip);
+                            break;
+                    }
+                }
+                catch (error) {
+                    // If the promise is rejected, select another random API and try again
+                    randomAPI = this.selectRandomAPI();
+                    retries++;
+                }
+            }
+            // If max retries reached and no response, return undefined
+            if (retries === this.maxRetries && !response) {
+                return undefined;
+            }
+            // Return the response
+            return response ? response : undefined;
+        });
+    }
+    selectRandomAPI() {
+        // Get a random entry from the enum
+        const randomEntry = Object.entries(apis_1.GeoAPIs)[Math.floor(Math.random() * Object.entries(apis_1.GeoAPIs).length)];
+        // Return the random entry
+        return randomEntry[1];
+    }
+    cacheResponse(ip, response) {
+        this.cache.set(ip, response);
+        // Remove from cache after timeout
+        setTimeout(() => this.cache.delete(ip), this.cacheTimeout);
+    }
+    fetchIPHyphenAPIDotCom(ip) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestURL = apis_1.GeoAPIs.IP_HYPHEN_API_DOT_COM + ip + "?fields=24899583";
+            const response = yield axios_1.default.get(requestURL);
+            if (response.data.status === "success") {
+                this.cacheResponse(ip, response.data);
+                return Promise.resolve({
+                    ip: response.data.query,
+                    country: response.data.countryCode,
+                    city: response.data.city,
+                    continent: response.data.continentCode,
+                    latitude: response.data.lat,
+                    longitude: response.data.lon,
+                    zip: response.data.zip,
+                    isp: response.data.isp,
+                    proxy: response.data.proxy,
+                    isHosting: response.data.hosting,
+                    source: "ip-api.com"
+                });
+            }
+            else {
+                return Promise.reject();
+            }
+        });
+    }
+    fetchFreeIPAPIDotCom(ip) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestURL = apis_1.GeoAPIs.FREE_IP_API_DOT_COM + ip;
+            const response = yield axios_1.default.get(requestURL);
+            if (response.data.ipVersion === 4) {
+                this.cacheResponse(ip, response.data);
+                return Promise.resolve({
+                    ip: response.data.ipAddress,
+                    country: response.data.countryCode,
+                    city: response.data.cityName,
+                    continent: response.data.continentCode,
+                    latitude: response.data.latitude,
+                    longitude: response.data.longitude,
+                    zip: response.data.zipCode,
+                    isp: response.data.isp,
+                    proxy: response.data.proxy,
+                    isHosting: response.data.hosting,
+                    source: "freeipapi.com"
+                });
+            }
+            else {
+                return Promise.reject();
+            }
+        });
+    }
+    fetchIPWhoDotIs(ip) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestURL = apis_1.GeoAPIs.IPWHO_DOT_IS + ip;
+            const response = yield axios_1.default.get(requestURL);
+            if (response.data.success) {
+                this.cacheResponse(ip, response.data);
+                return Promise.resolve({
+                    ip: response.data.ip,
+                    country: response.data.country_code,
+                    city: response.data.city,
+                    continent: response.data.continent_code,
+                    latitude: response.data.latitude,
+                    longitude: response.data.longitude,
+                    zip: response.data.postal,
+                    isp: response.data.connection.isp,
+                    proxy: false,
+                    isHosting: false,
+                    source: "ipwho.is"
+                });
+            }
+            else {
+                return Promise.reject();
+            }
+        });
+    }
+    fetchIPAPIDotCo(ip) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestURL = apis_1.GeoAPIs.IPAPI_DOT_CO + ip + "/json";
+            const response = yield axios_1.default.get(requestURL);
+            if (response.data.ip) {
+                this.cacheResponse(ip, response.data);
+                return Promise.resolve({
+                    ip: response.data.ip,
+                    country: response.data.country_code,
+                    city: response.data.city,
+                    continent: response.data.continent_code,
+                    latitude: response.data.latitude,
+                    longitude: response.data.longitude,
+                    zip: response.data.postal,
+                    isp: response.data.org,
+                    source: "ipapi.co"
+                });
+            }
+            else {
+                return Promise.reject();
+            }
+        });
+    }
+}
+exports.default = IPDox;

package/dist/types/IPDOXConstructor.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Interface for the constructor
+ *
+ * @interface IPDOXConstructor
+ * @property {number} cacheTimeout The cache timeout in milliseconds (default: 43200000 (12 hours))
+ * @property {number} maxRetries The maximum number of retries (default: 10)
+ */
+export interface IPDOXConstructor {
+    cacheTimeout?: number;
+    maxRetries?: number;
+}

package/dist/types/IPDOXConstructor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/IPDOXRequest.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Interface for the request
+ *
+ * @interface IPDOXRequest
+ * @property {string} ip The IP address
+ */
+export interface IPDOXRequest {
+    ip: string;
+}

package/dist/types/IPDOXRequest.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/IPDOXResponse.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Interface for the response
+ *
+ * @interface IPDOXResponse
+ * @property {string} ip The IP address
+ * @property {string} country The country (ISO 3166)
+ * @property {string} city The city
+ * @property {string} continent The continent (ISO 3166)
+ * @property {number} latitude The latitude
+ * @property {number} longitude The longitude
+ * @property {string} zip The ZIP code
+ * @property {string} isp The ISP (Internet Service Provider)
+ * @property {boolean} proxy Is the IP address a proxy?
+ * @property {boolean} isHosting Is the IP address a hosting provider?
+ * @property {object} proxyInfo Information about the proxy
+ * @property {boolean} proxyInfo.isVPN Is the IP address a VPN?
+ * @property {boolean} proxyInfo.isTOR Is the IP address a TOR node?
+ * @property {boolean} proxyInfo.isProxy Is the IP address a proxy?
+ * @property {string} source The source of the data
+ */
+export interface IPDOXResponse {
+    ip: string;
+    country: string;
+    city: string;
+    continent: string;
+    latitude: number;
+    longitude: number;
+    zip: string;
+    isp: string;
+    proxy?: boolean;
+    isHosting?: boolean;
+    proxyInfo?: {
+        isVPN: boolean;
+        isTOR: boolean;
+        isProxy: boolean;
+    };
+    source: string;
+}

package/dist/types/IPDOXResponse.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/apis.d.ts

@@ -0,0 +1,6 @@
+export declare enum GeoAPIs {
+    IP_HYPHEN_API_DOT_COM = "http://ip-api.com/json/",
+    FREE_IP_API_DOT_COM = "https://freeipapi.com/api/json/",
+    IPWHO_DOT_IS = "https://ipwho.is/",
+    IPAPI_DOT_CO = "https://ipapi.co/"
+}

package/dist/utils/apis.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoAPIs = void 0;
+var GeoAPIs;
+(function (GeoAPIs) {
+    GeoAPIs["IP_HYPHEN_API_DOT_COM"] = "http://ip-api.com/json/";
+    GeoAPIs["FREE_IP_API_DOT_COM"] = "https://freeipapi.com/api/json/";
+    GeoAPIs["IPWHO_DOT_IS"] = "https://ipwho.is/";
+    GeoAPIs["IPAPI_DOT_CO"] = "https://ipapi.co/";
+})(GeoAPIs || (exports.GeoAPIs = GeoAPIs = {}));

package/package.json

@@ -0,0 +1,33 @@
+{
+	"name": "node-ipdox",
+	"version": "1.0.0",
+	"description": "",
+	"author": "Mikel Calvo <contact@mikecalvo.net> (www.mikelcalvo.net)",
+	"keywords": ["geoip", "ip lookup", "ipdoxxing"],
+	"license": "ISC",
+	"readmeFilename": "README.md",
+	"homepage": "https://github.com/mikelcalvo/ipdox#readme",
+	"bugs": {
+		"url": "https://github.com/mikelcalvo/ipdox/issues"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": ["dist"],
+	"scripts": {
+		"test": "echo \"Error: no test specified\" && exit 1",
+		"format": "prettier --write \"**/*.ts\" \"**/*.js\" \"**/*.json\"",
+		"build": "tsc"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/mikelcalvo/node-ipdox.git"
+	},
+	"dependencies": {
+		"axios": "1.6.2"
+	},
+	"devDependencies": {
+		"@types/node": "20.10.1",
+		"prettier": "3.1.0",
+		"typescript": "^5.3.2"
+	}
+}