@k03mad/ip2geo 5.0.1 → 6.0.0

package/.husky/pre-commit

@@ -1,4 +1,2 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
-npm run lint && npm run test
+npm run lint
+npm run test

package/README.md

@@ -15,18 +15,22 @@ ip2geo
 ip2geo 1.1.1.1
 # {
 #   ip: '1.1.1.1',
-#   emoji: '🇺🇸',
+#   continent: 'North America',
+#   continentCode: 'NA',
 #   country: 'United States',
-#   countryA2: 'US',
+#   countryCode: 'US',
+#   countryEmoji: '🇺🇸',
 #   region: 'District of Columbia',
+#   regionCode: 'DC',
 #   city: 'Washington',
-#   org: 'APNIC and Cloudflare DNS Resolver project',
-#   isp: 'Cloudflare, Inc.',
-#   ispDomain: 'cloudflare.com'
+#   connectionAsn: 13335,
+#   connectionOrg: 'APNIC and Cloudflare DNS Resolver project',
+#   connectionIsp: 'Cloudflare, Inc.',
+#   connectionDomain: 'cloudflare.com'
 # }
 
 ip2geo 1.1.1.1 8.8.8.8 --json
-# [{"ip":"1.1.1.1","emoji":"🇺🇸","country":"United States","countryA2":"US","region":"District of Columbia","city":"Washington","org":"APNIC and Cloudflare DNS Resolver project","isp":"Cloudflare, Inc.","ispDomain":"cloudflare.com"},{"ip":"8.8.8.8","emoji":"🇺🇸","country":"United States","countryA2":"US","region":"California","city":"Mountain View","org":"Google LLC","isp":"Google LLC","ispDomain":"google.com"}]
+# [{"ip":"1.1.1.1","continent":"North America","continentCode":"NA","country":"United States","countryCode":"US","countryEmoji":"🇺🇸","region":"District of Columbia","regionCode":"DC","city":"Washington","connectionAsn":13335,"connectionOrg":"APNIC and Cloudflare DNS Resolver project","connectionIsp":"Cloudflare, Inc.","connectionDomain":"cloudflare.com"},{"ip":"8.8.8.8","continent":"North America","continentCode":"NA","country":"United States","countryCode":"US","countryEmoji":"🇺🇸","region":"California","regionCode":"CA","city":"Mountain View","connectionAsn":15169,"connectionOrg":"Google LLC","connectionIsp":"Google LLC","connectionDomain":"google.com"}]
 ```
 
 ## API
@@ -38,7 +42,8 @@ npm i @k03mad/ip2geo
 ```js
 import {ip2geo} from '@k03mad/ip2geo';
 
-const info = await ip2geo('1.1.1.1', {
+const info = await ip2geo({
+    ip: '1.1.1.1', // make key falsy to use current external IP
     // defaults
     cacheDir: path.join(os.tmpdir(), '.ip2geo'),
     cacheFileName: 'ips.log',
@@ -51,13 +56,17 @@ const info = await ip2geo('1.1.1.1', {
 
 // info {
 //   ip: '1.1.1.1',
-//   emoji: '🇺🇸',
+//   continent: 'North America',
+//   continentCode: 'NA',
 //   country: 'United States',
-//   countryA2: 'US',
+//   countryCode: 'US',
+//   countryEmoji: '🇺🇸',
 //   region: 'District of Columbia',
+//   regionCode: 'DC',
 //   city: 'Washington',
-//   org: 'APNIC and Cloudflare DNS Resolver project',
-//   isp: 'Cloudflare, Inc.',
-//   ispDomain: 'cloudflare.com'
+//   connectionAsn: 13335,
+//   connectionOrg: 'APNIC and Cloudflare DNS Resolver project',
+//   connectionIsp: 'Cloudflare, Inc.',
+//   connectionDomain: 'cloudflare.com'
 // }
 ```

package/app/cli.js

@@ -10,26 +10,30 @@ const args = process.argv.slice(2);
 const argsIps = args.filter(arg => !arg.startsWith('-'));
 
 if (args.includes('-h') || args.includes('--help')) {
-    const prefix = codeText('$');
-    const name = nameText('ip2geo');
-    const json = codeText('// json output for parse');
-    const multi = codeText('// multi IPs');
+    const cmd = `${codeText('$')} ${nameText('ip2geo')}`;
 
     log([
         '',
-        `${prefix} ${name}`,
-        `${prefix} ${name} 1.1.1.1`,
-        `${prefix} ${name} 1.1.1.1 -j       ${json}`,
-        `${prefix} ${name} 1.1.1.1 --json   ${json}`,
-        `${prefix} ${name} 1.1.1.1 8.8.8.8  ${multi}`,
-        `${prefix} ${name} 1.1.1.1,8.8.8.8  ${multi}`,
+        `${cmd} ${codeText('# current external ip')}`,
+        `${cmd} 1.1.1.1`,
+        '',
+        `${cmd} -h`,
+        `${cmd} --help`,
+        '',
+        `${cmd} 1.1.1.1 -j`,
+        `${cmd} 1.1.1.1 --json`,
+        '',
+        `${cmd} 1.1.1.1 8.8.8.8`,
+        `${cmd} 1.1.1.1,8.8.8.8`,
         '',
     ]);
+
+    process.exit(0);
 }
 
 const output = argsIps.length === 0
     ? [await ip2geo()]
-    : await Promise.all(argsIps.map(arg => Promise.all(arg.split(',').map(ip => ip2geo(ip)))));
+    : await Promise.all(argsIps.map(arg => Promise.all(arg.split(',').map(ip => ip2geo({ip})))));
 
 const flatten = output.flat();
 

package/app/helpers/cache.js

@@ -0,0 +1,151 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import _debug from 'debug';
+
+const debug = _debug('mad:geoip');
+
+const outputKeys = [
+    'ip',
+    'continent',
+    'continentCode',
+    'country',
+    'countryCode',
+    'countryEmoji',
+    'region',
+    'regionCode',
+    'city',
+    'connectionAsn',
+    'connectionOrg',
+    'connectionIsp',
+    'connectionDomain',
+];
+
+/**
+ * @param {Array<string>} dataArr
+ * @returns {object}
+ */
+export const collectOutputData = dataArr => {
+    const outputData = {};
+
+    outputKeys.forEach((key, i) => {
+        outputData[key] = dataArr[i];
+    });
+
+    return outputData;
+};
+
+/**
+ * @param {string} ip
+ * @param {string} cacheDir
+ * @param {string} cacheFileName
+ * @returns {string}
+ */
+const getCacheFileFullPath = (ip, cacheDir, cacheFileName) => {
+    const [firstOctet] = ip.split(/\.|:/);
+    return path.join(cacheDir, `${firstOctet}_${cacheFileName}`);
+};
+
+/**
+ * @param {string} ip
+ * @param {string} cacheDir
+ * @param {string} cacheFileName
+ * @param {string} cacheFileSeparator
+ * @param {string} cacheFileNewline
+ * @returns {Promise<object>}
+ */
+export const readFromFsCache = async (ip, cacheDir, cacheFileName, cacheFileSeparator, cacheFileNewline) => {
+    const cacheFileFull = getCacheFileFullPath(ip, cacheDir, cacheFileName);
+
+    try {
+        await fs.mkdir(cacheDir, {recursive: true});
+        const content = await fs.readFile(cacheFileFull, {encoding: 'utf8'});
+
+        if (content) {
+            const data = content.split(cacheFileNewline);
+
+            for (const elem of data) {
+                const fileData = elem.split(cacheFileSeparator);
+
+                if (ip === fileData[0]) {
+                    const outputData = collectOutputData(fileData);
+                    debug('get from fs cache: %o %o', cacheFileFull, outputData);
+                    return outputData;
+                }
+            }
+        }
+    } catch (err) {
+        if (err.code === 'ENOENT') {
+            await fs.appendFile(cacheFileFull, '');
+        } else {
+            throw err;
+        }
+    }
+};
+
+/**
+ * @param {string} ip
+ * @param {object} data
+ * @param {string} cacheDir
+ * @param {string} cacheFileName
+ * @param {string} cacheFileSeparator
+ * @param {string} cacheFileNewline
+ * @returns {Promise<void>}
+ */
+export const writeToFsCache = async (ip, data, cacheDir, cacheFileName, cacheFileSeparator, cacheFileNewline) => {
+    const cacheFileFull = getCacheFileFullPath(ip, cacheDir, cacheFileName);
+
+    await fs.mkdir(cacheDir, {recursive: true});
+    await fs.appendFile(cacheFileFull, Object.values(data).join(cacheFileSeparator) + cacheFileNewline);
+
+    debug('set to fs cache: %o %o', cacheFileFull, data);
+};
+
+/**
+ * @param {string} ip
+ * @param {Map} cacheMap
+ * @param {number} cacheMapMaxEntries
+ * @returns {object|undefined}
+ */
+export const readFromMapCache = (ip, cacheMap, cacheMapMaxEntries) => {
+    if (cacheMapMaxEntries > 0) {
+        const mapCache = cacheMap.get(ip);
+
+        if (mapCache) {
+            debug('get from map cache: %o', mapCache);
+            return mapCache;
+        }
+    }
+};
+
+/**
+ * @param {object} body
+ * @param {string} body.ip
+ * @param {Map} cacheMap
+ * @param {number} cacheMapMaxEntries
+ */
+export const writeToMapCache = (body, cacheMap, cacheMapMaxEntries) => {
+    if (cacheMapMaxEntries > 0) {
+        cacheMap.set(body.ip, body);
+        debug('set to map cache: %o', body);
+    }
+};
+
+/**
+ * @param {Map} cacheMap
+ * @param {number} cacheMapMaxEntries
+ */
+export const removeFromMapCacheIfLimit = (cacheMap, cacheMapMaxEntries) => {
+    if (cacheMap.size > cacheMapMaxEntries) {
+        debug('remove from map cache by limit: size %o, limit: %o', cacheMap.size, cacheMapMaxEntries);
+
+        for (const [key] of cacheMap) {
+            debug('remove from map cache by limit: key %o', key);
+            cacheMap.delete(key);
+
+            if (cacheMap.size <= cacheMapMaxEntries) {
+                break;
+            }
+        }
+    }
+};

package/app/lib/ip2geo.js

@@ -1,14 +1,44 @@
-import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
 import {request} from '@k03mad/request';
-import _debug from 'debug';
+import {logErrorExit} from '@k03mad/simple-log';
 
-const debug = _debug('mad:geoip');
+import {
+    collectOutputData,
+    readFromFsCache,
+    readFromMapCache,
+    removeFromMapCacheIfLimit,
+    writeToFsCache,
+    writeToMapCache,
+} from '../helpers/cache.js';
+
+const API = 'https://ipwho.is/';
+
+export const DEFAULT_CACHE_FILE_DIR = path.join(os.tmpdir(), '.ip2geo-cache');
+export const DEFAULT_CACHE_FILE_NAME = 'ip.log';
+export const DEFAULT_CACHE_FILE_SEPARATOR = ';;';
+export const DEFAULT_CACHE_FILE_NEWLINE = '\n';
+export const DEFAULT_CACHE_MAP_MAX_ENTRIES = Number.POSITIVE_INFINITY;
+export const DEFAULT_RPS = 3;
+
+export const cacheStorage = new Map();
 
 /**
- * @typedef {object} GeoIpOutput
+ * @typedef {object} ReqInput
+ * @property {object} [opts]
+ * @property {object} [opts.ip]
+ * @property {string} [opts.cacheDir]
+ * @property {string} [opts.cacheFileName]
+ * @property {string} [opts.cacheFileSeparator]
+ * @property {string} [opts.cacheFileNewline]
+ * @property {Map} [opts.cacheMap]
+ * @property {number} [opts.cacheMapMaxEntries]
+ * @property {number} [opts.rps]
+ */
+
+/**
+ * @typedef {object} ReqOutput
  * @property {string} [ip]
  * @property {string} [emoji]
  * @property {string} [country]
@@ -20,104 +50,12 @@ const debug = _debug('mad:geoip');
  * @property {string} [ispDomain]
  */
 
-const API = 'https://ipwho.is/';
-
-const DEFAULT_CACHE_FILE_DIR = path.join(os.tmpdir(), '.ip2geo');
-const DEFAULT_CACHE_FILE_NAME = 'ips.log';
-const DEFAULT_CACHE_FILE_SEPARATOR = ';;';
-const DEFAULT_CACHE_FILE_NEWLINE = '\n';
-const DEFAULT_CACHE_MAP_MAX_ENTRIES = Number.POSITIVE_INFINITY;
-const DEFAULT_RPS = 3;
-
-export const cacheStorage = new Map();
-
-const outputKeys = [
-    'ip',
-    'emoji',
-    'country',
-    'countryA2',
-    'region',
-    'city',
-    'org',
-    'isp',
-    'ispDomain',
-];
-
-/**
- * @param {Array<string>} dataArr
- * @returns {GeoIpOutput}
- */
-const collectOutputData = dataArr => {
-    const outputData = {};
-
-    outputKeys.forEach((key, i) => {
-        outputData[key] = dataArr[i];
-    });
-
-    return outputData;
-};
-
-/**
- * @param {string} ip
- * @param {string} cacheDir
- * @param {string} cacheFileName
- * @returns {string}
- */
-const getCacheFileFullPath = (ip, cacheDir, cacheFileName) => {
-    const [firstOctet] = ip.split(/\.|:/);
-    return path.join(cacheDir, `${firstOctet}_${cacheFileName}`);
-};
-
 /**
- * @param {string} ip
- * @param {string} cacheDir
- * @param {string} cacheFileName
- * @returns {Promise<string>}
+ * @param {ReqInput} opts
+ * @returns {Promise<ReqOutput>}
  */
-const readFromFsCache = async (ip, cacheDir, cacheFileName) => {
-    try {
-        await fs.mkdir(cacheDir, {recursive: true});
-        return await fs.readFile(getCacheFileFullPath(ip, cacheDir, cacheFileName), {encoding: 'utf8'});
-    } catch (err) {
-        if (err.code === 'ENOENT') {
-            await fs.appendFile(getCacheFileFullPath(ip, cacheDir, cacheFileName), '');
-        } else {
-            throw err;
-        }
-    }
-};
-
-/**
- * @param {string} ip
- * @param {Array[string]} data
- * @param {string} cacheDir
- * @param {string} cacheFileName
- * @param {string} cacheFileSeparator
- * @param {string} cacheFileNewline
- * @returns {Promise<void>}
- */
-const writeToFsCache = async (ip, data, cacheDir, cacheFileName, cacheFileSeparator, cacheFileNewline) => {
-    await fs.mkdir(cacheDir, {recursive: true});
-
-    await fs.appendFile(
-        getCacheFileFullPath(ip, cacheDir, cacheFileName),
-        data.join(cacheFileSeparator) + cacheFileNewline,
-    );
-};
-
-/**
- * @param {string} [ip]
- * @param {object} [opts]
- * @param {string} [opts.cacheDir]
- * @param {string} [opts.cacheFileName]
- * @param {string} [opts.cacheFileSeparator]
- * @param {string} [opts.cacheFileNewline]
- * @param {Map} [opts.cacheMap]
- * @param {number} [opts.cacheMapMaxEntries]
- * @param {number} [opts.rps]
- * @returns {Promise<GeoIpOutput>}
- */
-export const ip2geo = async (ip = '', {
+export const ip2geo = async ({
+    ip = '',
     cacheDir = DEFAULT_CACHE_FILE_DIR,
     cacheFileName = DEFAULT_CACHE_FILE_NAME,
     cacheFileSeparator = DEFAULT_CACHE_FILE_SEPARATOR,
@@ -127,82 +65,50 @@ export const ip2geo = async (ip = '', {
     rps = DEFAULT_RPS,
 } = {}) => {
     if (ip) {
-        if (cacheMapMaxEntries > 0) {
-            const ipData = cacheMap.get(ip);
+        const mapCache = readFromMapCache(ip, cacheMap, cacheMapMaxEntries);
 
-            if (ipData) {
-                debug('get from map cache: %o', ipData);
-                return ipData;
-            }
+        if (mapCache) {
+            return mapCache;
         }
 
         const fsCache = await readFromFsCache(ip, cacheDir, cacheFileName);
 
         if (fsCache) {
-            const data = fsCache.split(cacheFileNewline);
-
-            for (const elem of data) {
-                const fileData = elem.split(cacheFileSeparator);
-
-                if (ip === fileData[0]) {
-                    const outputData = collectOutputData(fileData);
-                    debug('get from fs cache: %o', outputData);
-
-                    if (cacheMapMaxEntries > 0) {
-                        cacheMap.set(ip, outputData);
-                        debug('set to map cache: %o', outputData);
-                    }
-
-                    return outputData;
-                }
-            }
+            writeToMapCache(fsCache, cacheMap, cacheMapMaxEntries);
+            return fsCache;
         }
     }
 
-    const {body} = await request(API + ip, {}, {rps});
+    const reqUrl = API + ip;
+    const {body} = await request(reqUrl, {}, {rps});
 
     if (!body?.ip) {
-        throw new Error(`API error:\n${body}`);
+        logErrorExit(['API error', `request: ${reqUrl}`, `response body: ${body}`]);
     }
 
-    const usedData = [
+    const outputData = collectOutputData([
         body.ip,
-        body?.flag?.emoji,
+        body?.continent,
+        body?.continent_code,
         body?.country,
         body?.country_code,
+        body?.flag?.emoji,
         body?.region,
+        body?.region_code,
         body?.city,
+        body?.connection?.asn,
         body?.connection?.org,
         body?.connection?.isp,
         body?.connection?.domain,
-    ];
-
-    const outputData = collectOutputData(usedData);
+    ]);
 
-    if (cacheMapMaxEntries > 0) {
-        cacheMap.set(body.ip, outputData);
-        debug('set to map cache: %o', outputData);
-    }
+    writeToMapCache(outputData, cacheMap, cacheMapMaxEntries);
+    removeFromMapCacheIfLimit(cacheMap, cacheMapMaxEntries);
 
     await writeToFsCache(
-        body.ip, usedData,
+        body.ip, outputData,
         cacheDir, cacheFileName, cacheFileSeparator, cacheFileNewline,
     );
 
-    debug('set to fs cache: %o', outputData);
-
-    if (cacheMap.size > cacheMapMaxEntries) {
-        debug('remove from map cache by limit: size %o, limit: %o', cacheMap.size, cacheMapMaxEntries);
-
-        for (const [key] of cacheMap) {
-            debug('remove from map cache by limit: key %o', key);
-            cacheMap.delete(key);
-
-            if (cacheMap.size <= cacheMapMaxEntries) {
-                break;
-            }
-        }
-    }
-
     return outputData;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k03mad/ip2geo",
-  "version": "5.0.1",
+  "version": "6.0.0",
   "description": "GeoIP library",
   "maintainers": [
     "Kirill Molchanov <k03.mad@gmail.com"
@@ -25,9 +25,9 @@
     "debug": "4.3.4"
   },
   "devDependencies": {
-    "@k03mad/eslint-config": "19.5.0",
+    "@k03mad/eslint-config": "20.2.0",
     "eslint": "8.56.0",
-    "husky": "8.0.3",
+    "husky": "9.0.5",
     "mocha": "10.2.0"
   },
   "scripts": {
@@ -38,6 +38,6 @@
     "clean:modules": "rm -rf ./node_modules || true",
     "clean:eslint:cache": "rm -rf .eslintcache || true",
     "setup": "npm run clean && pnpm i",
-    "prepare": "husky install || true"
+    "prepare": "husky || true"
   }
 }

package/tests/cache-file-modify.js

@@ -22,7 +22,7 @@ describe(testName, () => {
     it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
 
     it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
-        const data = await ip2geo(REQUEST_IPV4.ip, opts);
+        const data = await ip2geo({ip: REQUEST_IPV4.ip, ...opts});
         assert.deepEqual(data, REQUEST_IPV4);
     });
 

package/tests/cache-file-subfolder.js

@@ -26,7 +26,7 @@ describe(testName, () => {
     it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
 
     it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
-        const data = await ip2geo(REQUEST_IPV4.ip, opts);
+        const data = await ip2geo({ip: REQUEST_IPV4.ip, ...opts});
         assert.deepEqual(data, REQUEST_IPV4);
     });
 

package/tests/cache-map-entries.js

@@ -19,7 +19,7 @@ describe(testName, () => {
     it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
 
     it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
-        const data = await ip2geo(REQUEST_IPV4.ip, opts);
+        const data = await ip2geo({ip: REQUEST_IPV4.ip, ...opts});
         assert.deepEqual(data, REQUEST_IPV4);
     });
 
@@ -29,7 +29,7 @@ describe(testName, () => {
     });
 
     it(`should return correct response for IP: "${REQUEST_IPV6.ip}"`, async () => {
-        const data = await ip2geo(REQUEST_IPV6.ip, opts);
+        const data = await ip2geo({ip: REQUEST_IPV6.ip, ...opts});
         assert.deepEqual(data, REQUEST_IPV6);
     });
 

package/tests/cache-map-max-entries.js

@@ -30,7 +30,7 @@ describe(testName, () => {
 
     firstReqIps.forEach(ip => {
         it(`should request geo for IP: "${ip}"`, async () => {
-            await ip2geo(ip, opts);
+            await ip2geo({ip, ...opts});
         });
     });
 
@@ -41,7 +41,7 @@ describe(testName, () => {
 
     secondReqIps.forEach(ip => {
         it(`should request geo for IP: "${ip}"`, async () => {
-            await ip2geo(ip, opts);
+            await ip2geo({ip, ...opts});
         });
     });
 

package/tests/cache-map-off.js

@@ -19,7 +19,7 @@ describe(testName, () => {
     it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
 
     it(`should return correct response for IP: "${REQUEST_IPV4_MAP_OFF_ONLY.ip}"`, async () => {
-        const data = await ip2geo(REQUEST_IPV4_MAP_OFF_ONLY.ip, opts);
+        const data = await ip2geo({ip: REQUEST_IPV4_MAP_OFF_ONLY.ip, ...opts});
         assert.deepEqual(data, REQUEST_IPV4_MAP_OFF_ONLY);
     });
 

package/tests/default.js

@@ -15,7 +15,7 @@ describe(testName, () => {
 
     describe('with ip arg', () => {
         it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
-            const data = await ip2geo(REQUEST_IPV4.ip);
+            const data = await ip2geo({ip: REQUEST_IPV4.ip});
             assert.deepEqual(data, REQUEST_IPV4);
         });
 

package/tests/helpers/consts.js

@@ -1,45 +1,47 @@
-import os from 'node:os';
-import path from 'node:path';
-
-export const DEFAULT_OPTS = {
-    cacheDir: path.join(os.tmpdir(), '.ip2geo'),
-    cacheFileName: 'ips.log',
-    cacheFileSeparator: ';;',
-    cacheFileNewline: '\n',
-};
-
 export const REQUEST_IPV4 = {
     ip: '8.8.8.8',
-    emoji: '🇺🇸',
+    continent: 'North America',
+    continentCode: 'NA',
     country: 'United States',
-    countryA2: 'US',
+    countryCode: 'US',
+    countryEmoji: '🇺🇸',
     region: 'California',
+    regionCode: 'CA',
     city: 'Mountain View',
-    org: 'Google LLC',
-    isp: 'Google LLC',
-    ispDomain: 'google.com',
+    connectionAsn: 15_169,
+    connectionOrg: 'Google LLC',
+    connectionIsp: 'Google LLC',
+    connectionDomain: 'google.com',
 };
 
 export const REQUEST_IPV4_MAP_OFF_ONLY = {
     ip: '1.1.1.1',
-    emoji: '🇺🇸',
+    continent: 'North America',
+    continentCode: 'NA',
     country: 'United States',
-    countryA2: 'US',
+    countryCode: 'US',
+    countryEmoji: '🇺🇸',
     region: 'District of Columbia',
+    regionCode: 'DC',
     city: 'Washington',
-    org: 'APNIC and Cloudflare DNS Resolver project',
-    isp: 'Cloudflare, Inc.',
-    ispDomain: 'cloudflare.com',
+    connectionAsn: 13_335,
+    connectionOrg: 'APNIC and Cloudflare DNS Resolver project',
+    connectionIsp: 'Cloudflare, Inc.',
+    connectionDomain: 'cloudflare.com',
 };
 
 export const REQUEST_IPV6 = {
     ip: '2a00:dd80:40:100::',
-    emoji: '🇳🇱',
+    continent: 'Europe',
+    continentCode: 'EU',
     country: 'Netherlands',
-    countryA2: 'NL',
+    countryCode: 'NL',
+    countryEmoji: '🇳🇱',
     region: 'North Holland',
+    regionCode: 'NH',
     city: 'Amsterdam',
-    org: '',
-    isp: 'NetActuate Inc',
-    ispDomain: '',
+    connectionAsn: 0,
+    connectionOrg: '',
+    connectionIsp: 'NetActuate Inc',
+    connectionDomain: '',
 };

package/tests/ip-multi-requests-cache.js

@@ -21,7 +21,7 @@ describe(testName, () => {
 
     Array.from({length: opts.requestsCount}).forEach(() => {
         it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
-            const data = await ip2geo(REQUEST_IPV4.ip, opts);
+            const data = await ip2geo({ip: REQUEST_IPV4.ip, ...opts});
             assert.deepEqual(data, REQUEST_IPV4);
         });
     });

package/tests/ip-no-data.js

@@ -31,7 +31,7 @@ describe(testName, () => {
         });
 
         it(`should return empty response for IP: "${response.ip}"`, async () => {
-            const data = await ip2geo(response.ip, opts);
+            const data = await ip2geo({ip: response.ip, ...opts});
             assert.deepEqual(data, response);
         });
     });

package/tests/ip-v6.js

@@ -19,7 +19,7 @@ describe(testName, () => {
     it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
 
     it(`should return correct response for IP: "${REQUEST_IPV6.ip}"`, async () => {
-        const data = await ip2geo(REQUEST_IPV6.ip, opts);
+        const data = await ip2geo({ip: REQUEST_IPV6.ip, ...opts});
         assert.deepEqual(data, REQUEST_IPV6);
     });
 

package/tests/shared/fs.js

@@ -2,12 +2,17 @@ import assert from 'node:assert/strict';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
-import {DEFAULT_OPTS} from '../helpers/consts.js';
+import {
+    DEFAULT_CACHE_FILE_DIR,
+    DEFAULT_CACHE_FILE_NAME,
+    DEFAULT_CACHE_FILE_NEWLINE,
+    DEFAULT_CACHE_FILE_SEPARATOR,
+} from '../../app/index.js';
 
 /**
  * @param {string} cacheDir
  */
-export const removeCacheFolder = async (cacheDir = DEFAULT_OPTS.cacheDir) => {
+export const removeCacheFolder = async (cacheDir = DEFAULT_CACHE_FILE_DIR) => {
     try {
         await fs.rm(cacheDir, {recursive: true, force: true});
     } catch (err) {
@@ -26,10 +31,10 @@ export const removeCacheFolder = async (cacheDir = DEFAULT_OPTS.cacheDir) => {
  * @param {object} opts.response
  */
 export const checkCacheFile = async ({
-    cacheDir = DEFAULT_OPTS.cacheDir,
-    cacheFileName = DEFAULT_OPTS.cacheFileName,
-    cacheFileSeparator = DEFAULT_OPTS.cacheFileSeparator,
-    cacheFileNewline = DEFAULT_OPTS.cacheFileNewline,
+    cacheDir = DEFAULT_CACHE_FILE_DIR,
+    cacheFileName = DEFAULT_CACHE_FILE_NAME,
+    cacheFileSeparator = DEFAULT_CACHE_FILE_SEPARATOR,
+    cacheFileNewline = DEFAULT_CACHE_FILE_NEWLINE,
     response,
 }) => {
     const cacheFile = `${response.ip.split(/\.|:/)[0]}_${cacheFileName}`;