@k03mad/ip2geo 18.0.0 → 18.0.1

package/.editorconfig

@@ -8,8 +8,5 @@ indent_style = space
 insert_final_newline = true
 trim_trailing_whitespace = true
 
-[*.json]
-indent_size = 2
-
-[*.{yml,yaml}]
+[*.{json,yml,yaml}]
 indent_size = 2

package/.github/dependabot.yml

@@ -5,10 +5,10 @@ updates:
     schedule:
       interval: monthly
     assignees:
-      - "k03mad"
+      - 'k03mad'
   - package-ecosystem: github-actions
     directory: /
     schedule:
       interval: monthly
     assignees:
-      - "k03mad"
+      - 'k03mad'

package/.husky/pre-commit

@@ -1 +1 @@
-./node_modules/.bin/run-p -c lint test
+npm run lint && npm run test

package/.oxfmtrc.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "./node_modules/oxfmt/configuration_schema.json",
+  "ignorePatterns": ["node_modules/**"],
+  "singleQuote": true,
+  "arrowParens": "avoid",
+  "bracketSpacing": false,
+  "quoteProps": "consistent",
+  "experimentalSortImports": {
+    "groups": [
+      ["builtin"],
+      ["external", "type-external"],
+      ["internal", "type-internal"],
+      ["parent", "type-parent"],
+      ["sibling", "type-sibling"],
+      ["index", "type-index"]
+    ]
+  }
+}

package/.oxlintrc.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "extends": ["./node_modules/@k03mad/oxlint-config/.oxlintrc.json"],
+  "env": {
+    "node": true
+  }
+}

package/.vscode/settings.json

@@ -1,10 +1,3 @@
 {
-    "cSpell.words": [
-      "consts",
-      "dups",
-      "geoip",
-      "Netactuate",
-      "nvmrc",
-      "sonarjs"
-    ]
+  "cSpell.words": ["consts", "dups", "geoip", "Netactuate", "nvmrc", "sonarjs"]
 }

package/app/api.js

@@ -69,11 +69,7 @@ export const ip2geo = async ({
     concurrency,
 } = {}) => {
     if (ip) {
-        const mapCache = readFromMapCache(
-            ip,
-            cacheMap,
-            cacheMapMaxEntries,
-        );
+        const mapCache = readFromMapCache(ip, cacheMap, cacheMapMaxEntries);
 
         if (mapCache) {
             return mapCache;
@@ -88,11 +84,7 @@ export const ip2geo = async ({
         );
 
         if (fsCache) {
-            writeToMapCache(
-                fsCache,
-                cacheMap,
-                cacheMapMaxEntries,
-            );
+            writeToMapCache(fsCache, cacheMap, cacheMapMaxEntries);
 
             return fsCache;
         }
@@ -112,11 +104,11 @@ export const ip2geo = async ({
     const {body} = await request(reqUrl, {}, queueOpts);
 
     if (!body?.ip) {
-        throw new Error([
-            'API error',
-            `request: ${reqUrl}`,
-            `response body: ${JSON.stringify(body)}`,
-        ].join('\n'));
+        throw new Error(
+            ['API error', `request: ${reqUrl}`, `response body: ${JSON.stringify(body)}`].join(
+                '\n',
+            ),
+        );
     }
 
     const outputData = collectOutputData([
@@ -135,11 +127,7 @@ export const ip2geo = async ({
         body?.connection?.domain,
     ]);
 
-    writeToMapCache(
-        outputData,
-        cacheMap,
-        cacheMapMaxEntries,
-    );
+    writeToMapCache(outputData, cacheMap, cacheMapMaxEntries);
 
     await writeToFsCache(
         body.ip,

package/app/cli.js

@@ -2,7 +2,12 @@
 
 import chalk from 'chalk';
 
-import {DEFAULT_CACHE_FILE_DIR, DEFAULT_CACHE_FILE_NEWLINE, DEFAULT_CACHE_FILE_SEPARATOR, ip2geo} from './api.js';
+import {
+    DEFAULT_CACHE_FILE_DIR,
+    DEFAULT_CACHE_FILE_NEWLINE,
+    DEFAULT_CACHE_FILE_SEPARATOR,
+    ip2geo,
+} from './api.js';
 import {pruneCache} from './helpers/cache.js';
 import {codeText, nameText} from './helpers/colors.js';
 
@@ -17,25 +22,27 @@ const isPrune = args.includes('-p') || args.includes('--prune');
 if (isHelp) {
     const cmd = `${codeText('$')} ${nameText('ip2geo')}`;
 
-    console.log([
-        '',
-        codeText('# current external ip'),
-        cmd,
-        `${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`,
-        '',
-        codeText('# remove duplicate cache entries'),
-        `${cmd} -p`,
-        `${cmd} --prune`,
-    ].join('\n'));
+    console.log(
+        [
+            '',
+            codeText('# current external ip'),
+            cmd,
+            `${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`,
+            '',
+            codeText('# remove duplicate cache entries'),
+            `${cmd} -p`,
+            `${cmd} --prune`,
+        ].join('\n'),
+    );
 
     process.exit(0);
 }
@@ -45,47 +52,47 @@ if (isPrune) {
     console.log(blue(cacheFolder));
 
     try {
-        const {
-            different,
-            duplicates,
-            empty,
-            entries,
-            longLinesFiles,
-        } = await pruneCache(
+        const {different, duplicates, empty, entries, longLinesFiles} = await pruneCache(
             cacheFolder,
             DEFAULT_CACHE_FILE_SEPARATOR,
             DEFAULT_CACHE_FILE_NEWLINE,
         );
 
-        console.log([
-            '',
-            green(`Removed duplicate cache entries: ${bold(duplicates.length)}`),
-            ...duplicates.map(elem => dim(`— ${elem}`)),
-            green(`Removed different cache entries: ${bold(different.length)}`),
-            ...different.map(elem => dim(`— ${elem}`)),
-            green(`Removed empty cache entries: ${bold(empty.length)}`),
-            ...empty.map(elem => dim(`— ${elem}`)),
-        ].join('\n'));
+        console.log(
+            [
+                '',
+                green(`Removed duplicate cache entries: ${bold(duplicates.length)}`),
+                ...duplicates.map(elem => dim(`— ${elem}`)),
+                green(`Removed different cache entries: ${bold(different.length)}`),
+                ...different.map(elem => dim(`— ${elem}`)),
+                green(`Removed empty cache entries: ${bold(empty.length)}`),
+                ...empty.map(elem => dim(`— ${elem}`)),
+            ].join('\n'),
+        );
 
         if (longLinesFiles.length > 0) {
-            console.log([
-                red(`Required manual check, some cache files has too long lines: ${bold(longLinesFiles.length)}`),
-                ...longLinesFiles.map(({file, elem}) => dim(`— ${file}\n|— ${elem}`)),
-            ].join('\n'));
+            console.log(
+                [
+                    red(
+                        `Required manual check, some cache files has too long lines: ${bold(longLinesFiles.length)}`,
+                    ),
+                    ...longLinesFiles.map(({file, elem}) => dim(`— ${file}\n|— ${elem}`)),
+                ].join('\n'),
+            );
         }
 
-        console.log([
-            '',
-            green(`Current cache entries: ${bold(entries)}`),
-        ].join('\n'));
+        console.log(['', green(`Current cache entries: ${bold(entries)}`)].join('\n'));
     } catch (err) {
         console.error(red(err));
         process.exit(1);
     }
 } else {
-    const output = argsExtra.length === 0
-        ? [await ip2geo()]
-        : await Promise.all(argsExtra.map(arg => Promise.all(arg.split(',').map(ip => ip2geo({ip})))));
+    const output =
+        argsExtra.length === 0
+            ? [await ip2geo()]
+            : await Promise.all(
+                  argsExtra.map(arg => Promise.all(arg.split(',').map(ip => ip2geo({ip})))),
+              );
 
     const flatten = output.flat();
 

package/app/helpers/cache.js

@@ -32,9 +32,7 @@ export const collectOutputData = dataArr => {
     const outputData = {};
 
     outputKeys.forEach((key, i) => {
-        outputData[key] = key === 'connectionAsn' && dataArr[i]
-            ? Number(dataArr[i])
-            : dataArr[i];
+        outputData[key] = key === 'connectionAsn' && dataArr[i] ? Number(dataArr[i]) : dataArr[i];
     });
 
     return outputData;
@@ -59,7 +57,13 @@ const getCacheFileFullPath = (ip, cacheDir, cacheFileName) => {
  * @param {string} cacheFileNewline
  * @returns {Promise<object>}
  */
-export const readFromFsCache = async (ip, cacheDir, cacheFileName, cacheFileSeparator, cacheFileNewline) => {
+export const readFromFsCache = async (
+    ip,
+    cacheDir,
+    cacheFileName,
+    cacheFileSeparator,
+    cacheFileNewline,
+) => {
     const cacheFileFull = getCacheFileFullPath(ip, cacheDir, cacheFileName);
 
     try {
@@ -97,12 +101,23 @@ export const readFromFsCache = async (ip, cacheDir, cacheFileName, cacheFileSepa
  * @param {string} cacheFileNewline
  * @returns {Promise<void>}
  */
-export const writeToFsCache = async (ip, data, cacheDir, cacheFileName, cacheFileSeparator, cacheFileNewline) => {
+export const writeToFsCache = async (
+    ip,
+    data,
+    cacheDir,
+    cacheFileName,
+    cacheFileSeparator,
+    cacheFileNewline,
+) => {
     const cacheFileFull = getCacheFileFullPath(ip, cacheDir, cacheFileName);
     debug('set to fs cache: %o %o', cacheFileFull, data);
 
     await fs.mkdir(cacheDir, {recursive: true});
-    await fs.appendFile(cacheFileFull, cacheFileNewline + Object.values(data).join(cacheFileSeparator));
+
+    await fs.appendFile(
+        cacheFileFull,
+        cacheFileNewline + Object.values(data).join(cacheFileSeparator),
+    );
 };
 
 /**
@@ -164,81 +179,90 @@ export const writeToMapCache = (body, cacheMap, cacheMapMaxEntries) => {
 export const pruneCache = async (cacheDir, cacheFileSeparator, cacheFileNewline) => {
     const files = await fs.readdir(cacheDir);
 
-    await Promise.all(files.map(async file => {
-        const fullFilePath = path.join(cacheDir, file);
+    await Promise.all(
+        files.map(async file => {
+            const fullFilePath = path.join(cacheDir, file);
 
-        const [stat, data] = await Promise.all([
-            fs.lstat(fullFilePath),
-            fs.readFile(fullFilePath, {encoding: 'utf8'}),
-        ]);
+            const [stat, data] = await Promise.all([
+                fs.lstat(fullFilePath),
+                fs.readFile(fullFilePath, {encoding: 'utf8'}),
+            ]);
 
-        const firstIp = data
-            ?.split(cacheFileNewline)
-            ?.find(Boolean)
-            ?.split(cacheFileSeparator)[0];
+            const firstIp = data
+                ?.split(cacheFileNewline)
+                ?.find(Boolean)
+                ?.split(cacheFileSeparator)[0];
 
-        if (stat.isDirectory() || (firstIp && !isIP(firstIp))) {
-            throw new Error(`Folder has subfolders or files without IPs, wrong cache folder arg?\n${fullFilePath}`);
-        }
-    }));
-
-    const cacheLineToNum = line => Number(
-        line.split(cacheFileSeparator)[0]
-            .split('.')
-            .map(num => `00${num}`.slice(-3))
-            .join(''),
+            if (stat.isDirectory() || (firstIp && !isIP(firstIp))) {
+                throw new Error(
+                    `Folder has subfolders or files without IPs, wrong cache folder arg?\n${fullFilePath}`,
+                );
+            }
+        }),
     );
 
+    const cacheLineToNum = line =>
+        Number(
+            line
+                .split(cacheFileSeparator)[0]
+                .split('.')
+                .map(num => `00${num}`.slice(-3))
+                .join(''),
+        );
+
     const duplicates = new Set();
     const different = new Set();
     const empty = [];
     const longLinesFiles = new Set();
     let entries = 0;
 
-    await Promise.all(files.map(async file => {
-        const fullFilePath = path.join(cacheDir, file);
+    await Promise.all(
+        files.map(async file => {
+            const fullFilePath = path.join(cacheDir, file);
 
-        const data = await fs.readFile(fullFilePath, {encoding: 'utf8'});
-        const dataArr = data.split(cacheFileNewline).filter(Boolean);
+            const data = await fs.readFile(fullFilePath, {encoding: 'utf8'});
+            const dataArr = data.split(cacheFileNewline).filter(Boolean);
 
-        const dataArrRemoveEmpty = dataArr.filter(elem => {
-            const splitted = elem.split(cacheFileSeparator);
+            const dataArrRemoveEmpty = dataArr.filter(elem => {
+                const splitted = elem.split(cacheFileSeparator);
 
-            if (splitted.length > outputKeys.length) {
-                longLinesFiles.add({file: fullFilePath, elem});
-            }
+                if (splitted.length > outputKeys.length) {
+                    longLinesFiles.add({file: fullFilePath, elem});
+                }
 
-            if (splitted.filter(Boolean).length > 1) {
-                return true;
-            }
+                if (splitted.filter(Boolean).length > 1) {
+                    return true;
+                }
 
-            empty.push(elem);
-        });
+                empty.push(elem);
+            });
 
-        const uniqSorted = [...new Set(dataArrRemoveEmpty)]
-            .toSorted((a, b) => cacheLineToNum(a) - cacheLineToNum(b));
+            const uniqSorted = [...new Set(dataArrRemoveEmpty)].toSorted(
+                (a, b) => cacheLineToNum(a) - cacheLineToNum(b),
+            );
 
-        getArrayDups(dataArrRemoveEmpty).forEach(dup => duplicates.add(dup));
-        const dupsIp = getArrayDups(uniqSorted.map(elem => elem.split(cacheFileSeparator)[0]));
+            getArrayDups(dataArrRemoveEmpty).forEach(dup => duplicates.add(dup));
+            const dupsIp = getArrayDups(uniqSorted.map(elem => elem.split(cacheFileSeparator)[0]));
 
-        const removeDiffs = uniqSorted.filter(elem => {
-            if (dupsIp.includes(elem.split(cacheFileSeparator)[0])) {
-                different.add(elem);
-                return false;
-            }
+            const removeDiffs = uniqSorted.filter(elem => {
+                if (dupsIp.includes(elem.split(cacheFileSeparator)[0])) {
+                    different.add(elem);
+                    return false;
+                }
 
-            return true;
-        });
+                return true;
+            });
 
-        const fileContent = removeDiffs.join(cacheFileNewline).trim();
+            const fileContent = removeDiffs.join(cacheFileNewline).trim();
 
-        if (fileContent) {
-            await fs.writeFile(fullFilePath, fileContent);
-            entries += removeDiffs.length;
-        } else {
-            await fs.rm(fullFilePath);
-        }
-    }));
+            if (fileContent) {
+                await fs.writeFile(fullFilePath, fileContent);
+                entries += removeDiffs.length;
+            } else {
+                await fs.rm(fullFilePath);
+            }
+        }),
+    );
 
     return {
         entries,

package/package.json

@@ -1,39 +1,39 @@
 {
   "name": "@k03mad/ip2geo",
-  "version": "18.0.0",
+  "version": "18.0.1",
   "description": "GeoIP library",
+  "license": "MIT",
   "maintainers": [
     "Kirill Molchanov <k03.mad@gmail.com"
   ],
-  "bin": {
-    "ip2geo": "app/cli.js"
-  },
-  "main": "app/api.js",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/k03mad/ip2geo.git"
   },
-  "license": "MIT",
+  "bin": {
+    "ip2geo": "app/cli.js"
+  },
   "type": "module",
-  "engines": {
-    "node": ">=24"
+  "main": "app/api.js",
+  "scripts": {
+    "lint": "oxlint --report-unused-disable-directives && oxfmt --check",
+    "test": "rm -rfv ./.geoip && mocha tests --bail",
+    "prepare": "husky || true"
   },
   "dependencies": {
-    "@k03mad/request": "13.0.0",
+    "@k03mad/request": "14.0.2",
     "chalk": "5.6.2",
     "debug": "4.4.3",
     "is-ip": "5.0.1"
   },
   "devDependencies": {
-    "@k03mad/eslint-config": "34.1.0",
-    "eslint": "9.39.2",
+    "@k03mad/oxlint-config": "0.0.19",
     "husky": "9.1.7",
     "mocha": "11.7.5",
-    "npm-run-all": "4.1.5"
+    "oxfmt": "0.34.0",
+    "oxlint": "1.49.0"
   },
-  "scripts": {
-    "lint": "eslint ./ --cache",
-    "test": "rm -rfv ./.geoip && mocha tests --bail",
-    "prepare": "husky || true"
+  "engines": {
+    "node": ">=24"
   }
 }

package/tests/cache-file-entries.js

@@ -27,10 +27,11 @@ describe(testName, () => {
                 assert.deepEqual(data, REQUEST_IPV4);
             });
 
-            it('should have cache file', () => checkCacheFile({
-                ...opts,
-                response: REQUEST_IPV4,
-            }));
+            it('should have cache file', () =>
+                checkCacheFile({
+                    ...opts,
+                    response: REQUEST_IPV4,
+                }));
         });
     });
 });

package/tests/cache-file-modify.js

@@ -26,8 +26,9 @@ describe(testName, () => {
         assert.deepEqual(data, REQUEST_IPV4);
     });
 
-    it('should have cache file', () => checkCacheFile({
-        ...opts,
-        response: REQUEST_IPV4,
-    }));
+    it('should have cache file', () =>
+        checkCacheFile({
+            ...opts,
+            response: REQUEST_IPV4,
+        }));
 });

package/tests/cache-file-subfolder.js

@@ -15,11 +15,7 @@ describe(testName, () => {
     const SUBFOLDERS = 5;
 
     const opts = {
-        cacheDir: getTestFolder(
-            path.join(
-                ...Array.from({length: SUBFOLDERS}, () => testName),
-            ),
-        ),
+        cacheDir: getTestFolder(path.join(...Array.from({length: SUBFOLDERS}, () => testName))),
         cacheMap: new Map(),
     };
 
@@ -30,8 +26,9 @@ describe(testName, () => {
         assert.deepEqual(data, REQUEST_IPV4);
     });
 
-    it('should have cache file', () => checkCacheFile({
-        ...opts,
-        response: REQUEST_IPV4,
-    }));
+    it('should have cache file', () =>
+        checkCacheFile({
+            ...opts,
+            response: REQUEST_IPV4,
+        }));
 });

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

@@ -10,13 +10,7 @@ import {removeCacheFolder} from './shared/fs.js';
 const testName = getCurrentFilename(import.meta.url);
 
 describe(testName, () => {
-    const firstReqIps = [
-        '10.10.10.10',
-        '20.20.20.20',
-        '30.30.30.30',
-        '40.40.40.40',
-        '50.50.50.50',
-    ];
+    const firstReqIps = ['10.10.10.10', '20.20.20.20', '30.30.30.30', '40.40.40.40', '50.50.50.50'];
 
     const secondReqIps = ['60.60.60.60'];
 

package/tests/cache-map-off.js

@@ -23,10 +23,11 @@ describe(testName, () => {
         assert.deepEqual(data, REQUEST_IPV4_MAP_OFF_ONLY);
     });
 
-    it('should have cache file', () => checkCacheFile({
-        ...opts,
-        response: REQUEST_IPV4_MAP_OFF_ONLY,
-    }));
+    it('should have cache file', () =>
+        checkCacheFile({
+            ...opts,
+            response: REQUEST_IPV4_MAP_OFF_ONLY,
+        }));
 
     it('should not have cache entries', () => {
         assert.equal(cacheStorage.size, 0);

package/tests/default.js

@@ -19,9 +19,10 @@ describe(testName, () => {
             assert.deepEqual(data, REQUEST_IPV4);
         });
 
-        it('should have cache file', () => checkCacheFile({
-            response: REQUEST_IPV4,
-        }));
+        it('should have cache file', () =>
+            checkCacheFile({
+                response: REQUEST_IPV4,
+            }));
 
         it('should have 1 correct cache entry', () => {
             assert.equal(cacheStorage.size, 1);

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

@@ -26,10 +26,11 @@ describe(testName, () => {
         });
     });
 
-    it('should have cache file', () => checkCacheFile({
-        ...opts,
-        response: REQUEST_IPV4,
-    }));
+    it('should have cache file', () =>
+        checkCacheFile({
+            ...opts,
+            response: REQUEST_IPV4,
+        }));
 
     it('should have 1 correct cache entry', () => {
         assert.equal(opts.cacheMap.size, 1);

package/tests/ip-no-data.js

@@ -11,10 +11,7 @@ import {removeCacheFolder} from './shared/fs.js';
 const testName = getCurrentFilename(import.meta.url);
 
 describe(testName, () => {
-    const responses = [
-        {ip: '10.10.10.10'},
-        {ip: 'test'},
-    ];
+    const responses = [{ip: '10.10.10.10'}, {ip: 'test'}];
 
     const opts = {
         cacheDir: getTestFolder(testName),

package/tests/ip-v6.js

@@ -23,8 +23,9 @@ describe.skip(testName, () => {
         assert.deepEqual(data, REQUEST_IPV6);
     });
 
-    it('should have cache file', () => checkCacheFile({
-        ...opts,
-        response: REQUEST_IPV6,
-    }));
+    it('should have cache file', () =>
+        checkCacheFile({
+            ...opts,
+            response: REQUEST_IPV6,
+        }));
 });

package/eslint.config.js

@@ -1 +0,0 @@
-export {default} from '@k03mad/eslint-config';