@prosopo/ipinfo 0.2.14 → 0.2.15

package/dist/backends/maxmind.js

@@ -1,150 +1,147 @@
-export class MaxMindBackend {
-    constructor(config) {
-        this.cityReader = null;
-        this.asnReader = null;
-        this.config = config;
+class MaxMindBackend {
+  constructor(config) {
+    this.cityReader = null;
+    this.asnReader = null;
+    this.config = config;
+  }
+  async initialize() {
+    const { Reader } = await import("@maxmind/geoip2-node");
+    if (this.config.cityDbPath) {
+      try {
+        this.cityReader = await Reader.open(this.config.cityDbPath);
+        this.config.logger?.info(() => ({
+          msg: "MaxMind City reader initialized",
+          data: { dbPath: this.config.cityDbPath }
+        }));
+      } catch (error) {
+        this.config.logger?.warn(() => ({
+          msg: "Failed to initialize MaxMind City reader",
+          err: error,
+          data: { dbPath: this.config.cityDbPath }
+        }));
+      }
     }
-    async initialize() {
-        const { Reader } = await import("@maxmind/geoip2-node");
-        if (this.config.cityDbPath) {
-            try {
-                this.cityReader = await Reader.open(this.config.cityDbPath);
-                this.config.logger?.info(() => ({
-                    msg: "MaxMind City reader initialized",
-                    data: { dbPath: this.config.cityDbPath },
-                }));
-            }
-            catch (error) {
-                this.config.logger?.warn(() => ({
-                    msg: "Failed to initialize MaxMind City reader",
-                    err: error,
-                    data: { dbPath: this.config.cityDbPath },
-                }));
-            }
-        }
-        if (this.config.asnDbPath) {
-            try {
-                this.asnReader = await Reader.open(this.config.asnDbPath);
-                this.config.logger?.info(() => ({
-                    msg: "MaxMind ASN reader initialized",
-                    data: { dbPath: this.config.asnDbPath },
-                }));
-            }
-            catch (error) {
-                this.config.logger?.warn(() => ({
-                    msg: "Failed to initialize MaxMind ASN reader",
-                    err: error,
-                    data: { dbPath: this.config.asnDbPath },
-                }));
-            }
-        }
+    if (this.config.asnDbPath) {
+      try {
+        this.asnReader = await Reader.open(this.config.asnDbPath);
+        this.config.logger?.info(() => ({
+          msg: "MaxMind ASN reader initialized",
+          data: { dbPath: this.config.asnDbPath }
+        }));
+      } catch (error) {
+        this.config.logger?.warn(() => ({
+          msg: "Failed to initialize MaxMind ASN reader",
+          err: error,
+          data: { dbPath: this.config.asnDbPath }
+        }));
+      }
     }
-    isAvailable() {
-        return this.cityReader !== null || this.asnReader !== null;
+  }
+  isAvailable() {
+    return this.cityReader !== null || this.asnReader !== null;
+  }
+  async lookup(ip) {
+    if (!this.isAvailable()) {
+      return {
+        isValid: false,
+        error: "MaxMind readers not initialized",
+        ip
+      };
     }
-    async lookup(ip) {
-        if (!this.isAvailable()) {
-            return {
-                isValid: false,
-                error: "MaxMind readers not initialized",
-                ip,
-            };
-        }
+    try {
+      let cityData;
+      let asnData;
+      if (this.cityReader) {
         try {
-            let cityData;
-            let asnData;
-            if (this.cityReader) {
-                try {
-                    cityData = this.cityReader.city(ip);
-                }
-                catch (error) {
-                    this.config.logger?.debug(() => ({
-                        msg: "MaxMind City lookup failed",
-                        data: { ip },
-                        err: error,
-                    }));
-                }
-            }
-            if (this.asnReader) {
-                try {
-                    asnData = this.asnReader.asn(ip);
-                }
-                catch (error) {
-                    this.config.logger?.debug(() => ({
-                        msg: "MaxMind ASN lookup failed",
-                        data: { ip },
-                        err: error,
-                    }));
-                }
-            }
-            if (!cityData && !asnData) {
-                return {
-                    isValid: false,
-                    error: "No MaxMind data available for IP",
-                    ip,
-                };
-            }
-            const result = {
-                ip,
-                isValid: true,
-                isVPN: cityData?.traits?.isAnonymousVpn ?? false,
-                isTor: cityData?.traits?.isTorExitNode ?? false,
-                isProxy: (cityData?.traits?.isPublicProxy ?? false) ||
-                    (cityData?.traits?.isResidentialProxy ?? false),
-                isDatacenter: cityData?.traits?.isHostingProvider ?? false,
-                isAbuser: false,
-                isMobile: false,
-                isSatellite: cityData?.traits?.isSatelliteProvider ?? false,
-                isCrawler: false,
-                country: cityData?.country?.names?.en,
-                countryCode: cityData?.country?.isoCode,
-                region: cityData?.subdivisions?.[0]?.names?.en,
-                city: cityData?.city?.names?.en,
-                latitude: cityData?.location?.latitude,
-                longitude: cityData?.location?.longitude,
-                timezone: cityData?.location?.timeZone,
-                asnNumber: cityData?.traits?.autonomousSystemNumber ??
-                    asnData?.autonomousSystemNumber,
-                asnOrganization: cityData?.traits?.autonomousSystemOrganization ??
-                    asnData?.autonomousSystemOrganization,
-                providerName: cityData?.traits?.autonomousSystemOrganization ??
-                    asnData?.autonomousSystemOrganization,
-                providerType: mapUserType(cityData?.traits?.userType),
-            };
-            return result;
+          cityData = this.cityReader.city(ip);
+        } catch (error) {
+          this.config.logger?.debug(() => ({
+            msg: "MaxMind City lookup failed",
+            data: { ip },
+            err: error
+          }));
         }
-        catch (error) {
-            return {
-                isValid: false,
-                error: `MaxMind lookup error: ${error instanceof Error ? error.message : String(error)}`,
-                ip,
-            };
+      }
+      if (this.asnReader) {
+        try {
+          asnData = this.asnReader.asn(ip);
+        } catch (error) {
+          this.config.logger?.debug(() => ({
+            msg: "MaxMind ASN lookup failed",
+            data: { ip },
+            err: error
+          }));
         }
+      }
+      if (!cityData && !asnData) {
+        return {
+          isValid: false,
+          error: "No MaxMind data available for IP",
+          ip
+        };
+      }
+      const result = {
+        ip,
+        isValid: true,
+        // Threat indicators - GeoLite2 free DBs do not populate these
+        isVPN: cityData?.traits?.isAnonymousVpn ?? false,
+        isTor: cityData?.traits?.isTorExitNode ?? false,
+        isProxy: (cityData?.traits?.isPublicProxy ?? false) || (cityData?.traits?.isResidentialProxy ?? false),
+        isDatacenter: cityData?.traits?.isHostingProvider ?? false,
+        isAbuser: false,
+        isMobile: false,
+        isSatellite: cityData?.traits?.isSatelliteProvider ?? false,
+        isCrawler: false,
+        // Geolocation from City DB
+        country: cityData?.country?.names?.en,
+        countryCode: cityData?.country?.isoCode,
+        region: cityData?.subdivisions?.[0]?.names?.en,
+        city: cityData?.city?.names?.en,
+        latitude: cityData?.location?.latitude,
+        longitude: cityData?.location?.longitude,
+        timezone: cityData?.location?.timeZone,
+        // ASN info - prefer City DB traits, fall back to ASN DB
+        asnNumber: cityData?.traits?.autonomousSystemNumber ?? asnData?.autonomousSystemNumber,
+        asnOrganization: cityData?.traits?.autonomousSystemOrganization ?? asnData?.autonomousSystemOrganization,
+        // Provider info from ASN
+        providerName: cityData?.traits?.autonomousSystemOrganization ?? asnData?.autonomousSystemOrganization,
+        providerType: mapUserType(cityData?.traits?.userType)
+      };
+      return result;
+    } catch (error) {
+      return {
+        isValid: false,
+        error: `MaxMind lookup error: ${error instanceof Error ? error.message : String(error)}`,
+        ip
+      };
     }
+  }
 }
 function mapUserType(userType) {
-    switch (userType) {
-        case "hosting":
-        case "content_delivery_network":
-            return "hosting";
-        case "college":
-        case "school":
-        case "library":
-            return "education";
-        case "government":
-        case "military":
-            return "government";
-        case "business":
-            return "business";
-        case "residential":
-        case "cellular":
-        case "dialup":
-        case "cafe":
-        case "traveler":
-        case "router":
-            return "isp";
-        default:
-            return undefined;
-    }
+  switch (userType) {
+    case "hosting":
+    case "content_delivery_network":
+      return "hosting";
+    case "college":
+    case "school":
+    case "library":
+      return "education";
+    case "government":
+    case "military":
+      return "government";
+    case "business":
+      return "business";
+    case "residential":
+    case "cellular":
+    case "dialup":
+    case "cafe":
+    case "traveler":
+    case "router":
+      return "isp";
+    default:
+      return void 0;
+  }
 }
-//# sourceMappingURL=maxmind.js.map
+export {
+  MaxMindBackend
+};

package/dist/cjs/IpInfoService.cjs

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ipapi = require("./backends/ipapi.cjs");
+const maxmind = require("./backends/maxmind.cjs");
+function isNonRoutable(ip) {
+  const normalized = ip.replace(/^::ffff:/i, "");
+  if (normalized.startsWith("127.") || normalized.startsWith("10.") || normalized.startsWith("192.168.") || normalized.startsWith("169.254.") || normalized === "0.0.0.0") {
+    return true;
+  }
+  if (normalized.startsWith("172.")) {
+    const second = Number.parseInt(normalized.split(".")[1] ?? "", 10);
+    if (second >= 16 && second <= 31) return true;
+  }
+  if (normalized === "::1" || normalized === "::") return true;
+  if (/^f[cd]/i.test(normalized)) return true;
+  if (/^fe[89ab]/i.test(normalized)) return true;
+  return false;
+}
+class IpInfoService {
+  constructor(config) {
+    this.maxmindBackend = null;
+    this.ipapiBackend = null;
+    this.config = config;
+    if (config.maxmindCityDbPath || config.maxmindAsnDbPath) {
+      this.maxmindBackend = new maxmind.MaxMindBackend({
+        cityDbPath: config.maxmindCityDbPath,
+        asnDbPath: config.maxmindAsnDbPath,
+        logger: config.logger
+      });
+    }
+    if (config.ipapiUrl) {
+      this.ipapiBackend = new ipapi.IpapiBackend({
+        baseUrl: config.ipapiUrl,
+        apiKey: config.ipapiKey,
+        logger: config.logger
+      });
+    }
+  }
+  async initialize() {
+    if (this.maxmindBackend) {
+      await this.maxmindBackend.initialize();
+    }
+    this.config.logger?.info(() => ({
+      msg: "IpInfoService initialized",
+      data: {
+        maxmindAvailable: this.maxmindBackend?.isAvailable() ?? false,
+        ipapiAvailable: this.ipapiBackend?.isAvailable() ?? false
+      }
+    }));
+  }
+  isAvailable() {
+    return (this.maxmindBackend?.isAvailable() ?? false) || (this.ipapiBackend?.isAvailable() ?? false);
+  }
+  async lookup(ip) {
+    if (isNonRoutable(ip)) {
+      return {
+        isValid: false,
+        error: "Non-routable IP address",
+        ip
+      };
+    }
+    if (this.ipapiBackend?.isAvailable()) {
+      const result = await this.ipapiBackend.lookup(ip);
+      if (result.isValid) {
+        return result;
+      }
+      this.config.logger?.debug(() => ({
+        msg: "ipapi.is lookup failed, falling back to MaxMind",
+        data: {
+          ip,
+          error: "error" in result ? result.error : "unknown"
+        }
+      }));
+      if (this.maxmindBackend?.isAvailable()) {
+        return this.maxmindBackend.lookup(ip);
+      }
+      return result;
+    }
+    if (this.maxmindBackend?.isAvailable()) {
+      return this.maxmindBackend.lookup(ip);
+    }
+    return {
+      isValid: false,
+      error: "No IP info backend available",
+      ip
+    };
+  }
+}
+exports.IpInfoService = IpInfoService;

package/dist/cjs/backends/ipapi.cjs

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const TIMEOUT_MS = 700;
+class IpapiBackend {
+  constructor(config) {
+    this.config = config;
+  }
+  isAvailable() {
+    return Boolean(this.config.baseUrl);
+  }
+  async lookup(ip) {
+    try {
+      if (!ip || typeof ip !== "string") {
+        return {
+          isValid: false,
+          error: "Invalid IP address provided",
+          ip: ip || "undefined"
+        };
+      }
+      const body = { q: ip };
+      if (this.config.apiKey) {
+        body.key = this.config.apiKey;
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), TIMEOUT_MS);
+      try {
+        const response = await fetch(this.config.baseUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json"
+          },
+          body: JSON.stringify(body),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          return {
+            isValid: false,
+            error: `API request failed with status ${response.status}: ${response.statusText}`,
+            ip
+          };
+        }
+        const data = await response.json();
+        if (data.is_bogon) {
+          return {
+            isValid: false,
+            error: "IP address is bogon (non-routable)",
+            ip
+          };
+        }
+        const result = {
+          ip: data.ip,
+          isValid: true,
+          isVPN: data.is_vpn,
+          isTor: data.is_tor,
+          isProxy: data.is_proxy,
+          isDatacenter: data.is_datacenter,
+          isAbuser: data.is_abuser,
+          isMobile: data.is_mobile,
+          isSatellite: data.is_satellite,
+          isCrawler: data.is_crawler,
+          providerName: data.company?.name || data.datacenter?.datacenter,
+          providerType: data.company?.type || data.asn?.type,
+          asnNumber: data.asn?.asn,
+          asnOrganization: data.asn?.org,
+          country: data.location?.country,
+          countryCode: data.location?.country_code,
+          region: data.location?.state,
+          city: data.location?.city,
+          latitude: data.location?.latitude,
+          longitude: data.location?.longitude,
+          timezone: data.location?.timezone,
+          vpnService: data.vpn?.service,
+          vpnType: data.vpn?.type,
+          abuserScore: Number.parseFloat(
+            data.asn?.abuser_score.split(" ")[0] || "0"
+          ),
+          companyAbuserScore: Number.parseFloat(
+            data.company?.abuser_score.split(" ")[0] || "0"
+          )
+        };
+        return result;
+      } catch (fetchError) {
+        clearTimeout(timeoutId);
+        if (fetchError instanceof Error && fetchError.name === "AbortError") {
+          return {
+            isValid: false,
+            error: `Request timed out after ${TIMEOUT_MS}ms`,
+            ip
+          };
+        }
+        throw fetchError;
+      }
+    } catch (error) {
+      return {
+        isValid: false,
+        error: `Network or parsing error: ${error instanceof Error ? error.message : String(error)}`,
+        ip
+      };
+    }
+  }
+}
+exports.IpapiBackend = IpapiBackend;

package/dist/cjs/backends/maxmind.cjs

@@ -0,0 +1,169 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class MaxMindBackend {
+  constructor(config) {
+    this.cityReader = null;
+    this.asnReader = null;
+    this.config = config;
+  }
+  async initialize() {
+    const { Reader } = await import("@maxmind/geoip2-node");
+    if (this.config.cityDbPath) {
+      try {
+        this.cityReader = await Reader.open(this.config.cityDbPath);
+        this.config.logger?.info(() => ({
+          msg: "MaxMind City reader initialized",
+          data: { dbPath: this.config.cityDbPath }
+        }));
+      } catch (error) {
+        this.config.logger?.warn(() => ({
+          msg: "Failed to initialize MaxMind City reader",
+          err: error,
+          data: { dbPath: this.config.cityDbPath }
+        }));
+      }
+    }
+    if (this.config.asnDbPath) {
+      try {
+        this.asnReader = await Reader.open(this.config.asnDbPath);
+        this.config.logger?.info(() => ({
+          msg: "MaxMind ASN reader initialized",
+          data: { dbPath: this.config.asnDbPath }
+        }));
+      } catch (error) {
+        this.config.logger?.warn(() => ({
+          msg: "Failed to initialize MaxMind ASN reader",
+          err: error,
+          data: { dbPath: this.config.asnDbPath }
+        }));
+      }
+    }
+  }
+  isAvailable() {
+    return this.cityReader !== null || this.asnReader !== null;
+  }
+  async lookup(ip) {
+    if (!this.isAvailable()) {
+      return {
+        isValid: false,
+        error: "MaxMind readers not initialized",
+        ip
+      };
+    }
+    try {
+      let cityData;
+      let asnData;
+      if (this.cityReader) {
+        try {
+          cityData = this.cityReader.city(ip);
+        } catch (error) {
+          this.config.logger?.debug(() => ({
+            msg: "MaxMind City lookup failed",
+            data: { ip },
+            err: error
+          }));
+        }
+      }
+      if (this.asnReader) {
+        try {
+          asnData = this.asnReader.asn(ip);
+        } catch (error) {
+          this.config.logger?.debug(() => ({
+            msg: "MaxMind ASN lookup failed",
+            data: { ip },
+            err: error
+          }));
+        }
+      }
+      if (!cityData && !asnData) {
+        return {
+          isValid: false,
+          error: "No MaxMind data available for IP",
+          ip
+        };
+      }
+      const result = {
+        ip,
+        isValid: true,
+        // Threat indicators - GeoLite2 free DBs do not populate these
+        isVPN: cityData?.traits?.isAnonymousVpn ?? false,
+        isTor: cityData?.traits?.isTorExitNode ?? false,
+        isProxy: (cityData?.traits?.isPublicProxy ?? false) || (cityData?.traits?.isResidentialProxy ?? false),
+        isDatacenter: cityData?.traits?.isHostingProvider ?? false,
+        isAbuser: false,
+        isMobile: false,
+        isSatellite: cityData?.traits?.isSatelliteProvider ?? false,
+        isCrawler: false,
+        // Geolocation from City DB
+        country: cityData?.country?.names?.en,
+        countryCode: cityData?.country?.isoCode,
+        region: cityData?.subdivisions?.[0]?.names?.en,
+        city: cityData?.city?.names?.en,
+        latitude: cityData?.location?.latitude,
+        longitude: cityData?.location?.longitude,
+        timezone: cityData?.location?.timeZone,
+        // ASN info - prefer City DB traits, fall back to ASN DB
+        asnNumber: cityData?.traits?.autonomousSystemNumber ?? asnData?.autonomousSystemNumber,
+        asnOrganization: cityData?.traits?.autonomousSystemOrganization ?? asnData?.autonomousSystemOrganization,
+        // Provider info from ASN
+        providerName: cityData?.traits?.autonomousSystemOrganization ?? asnData?.autonomousSystemOrganization,
+        providerType: mapUserType(cityData?.traits?.userType)
+      };
+      return result;
+    } catch (error) {
+      return {
+        isValid: false,
+        error: `MaxMind lookup error: ${error instanceof Error ? error.message : String(error)}`,
+        ip
+      };
+    }
+  }
+}
+function mapUserType(userType) {
+  switch (userType) {
+    case "hosting":
+    case "content_delivery_network":
+      return "hosting";
+    case "college":
+    case "school":
+    case "library":
+      return "education";
+    case "government":
+    case "military":
+      return "government";
+    case "business":
+      return "business";
+    case "residential":
+    case "cellular":
+    case "dialup":
+    case "cafe":
+    case "traveler":
+    case "router":
+      return "isp";
+    default:
+      return void 0;
+  }
+}
+exports.MaxMindBackend = MaxMindBackend;

package/dist/cjs/index.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const IpInfoService = require("./IpInfoService.cjs");
+exports.IpInfoService = IpInfoService.IpInfoService;

package/dist/index.js

@@ -1,2 +1,4 @@
-export { IpInfoService } from "./IpInfoService.js";
-//# sourceMappingURL=index.js.map
+import { IpInfoService } from "./IpInfoService.js";
+export {
+  IpInfoService
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prosopo/ipinfo",
-	"version": "0.2.14",
+	"version": "0.2.15",
 	"description": "IP information service with MaxMind and ipapi.is backends",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -27,7 +27,7 @@
 	"dependencies": {
 		"@maxmind/geoip2-node": "5.0.0",
 		"@prosopo/logger": "1.0.2",
-		"@prosopo/types": "4.3.0"
+		"@prosopo/types": "4.3.1"
 	},
 	"devDependencies": {
 		"@prosopo/config": "3.3.1",