@k03mad/ip2geo 19.3.3 → 20.0.0

package/.vscode/settings.json

@@ -23,5 +23,6 @@
   },
   "[typescript]": {
     "editor.defaultFormatter": "oxc.oxc-vscode"
-  }
+  },
+  "cSpell.words": ["geoip", "oxfmt", "oxfmtrc", "oxlint"]
 }

package/app/api.ts

@@ -0,0 +1,120 @@
+import os from 'node:os';
+import path from 'node:path';
+
+import {
+  collectOutputData,
+  readFromFsCache,
+  readFromMapCache,
+  writeToFsCache,
+  writeToMapCache,
+} from './helpers/cache.ts';
+import type {ReqOutput} from './types.ts';
+
+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 interface ReqInput {
+  ip?: string;
+  cacheDir?: string;
+  cacheFileName?: string;
+  cacheFileSeparator?: string;
+  cacheFileNewline?: string;
+  cacheMap?: Map<string, ReqOutput>;
+  cacheMapMaxEntries?: number;
+}
+
+interface ApiResponseBody {
+  ip?: string;
+  continent?: string;
+  continent_code?: string;
+  country?: string;
+  country_code?: string;
+  flag?: {emoji?: string};
+  region?: string;
+  region_code?: string;
+  city?: string;
+  connection?: {
+    asn?: number | string;
+    org?: string;
+    isp?: string;
+    domain?: string;
+  };
+}
+
+export const cacheStorage = new Map<string, ReqOutput>();
+
+export const ip2geo = async ({
+  ip = '',
+  cacheDir = DEFAULT_CACHE_FILE_DIR,
+  cacheFileName = DEFAULT_CACHE_FILE_NAME,
+  cacheFileSeparator = DEFAULT_CACHE_FILE_SEPARATOR,
+  cacheFileNewline = DEFAULT_CACHE_FILE_NEWLINE,
+  cacheMapMaxEntries = DEFAULT_CACHE_MAP_MAX_ENTRIES,
+  cacheMap = cacheStorage,
+}: ReqInput = {}): Promise<ReqOutput> => {
+  if (ip) {
+    const mapCache = readFromMapCache(ip, cacheMap, cacheMapMaxEntries);
+
+    if (mapCache) {
+      return mapCache;
+    }
+
+    const fsCache = await readFromFsCache(
+      ip,
+      cacheDir,
+      cacheFileName,
+      cacheFileSeparator,
+      cacheFileNewline,
+    );
+
+    if (fsCache) {
+      writeToMapCache(fsCache, cacheMap, cacheMapMaxEntries);
+
+      return fsCache;
+    }
+  }
+
+  const reqUrl = API + ip;
+  const response = await fetch(reqUrl);
+  const body = (await response.json()) as ApiResponseBody;
+
+  if (!body?.ip) {
+    throw new Error(
+      ['API error', `request: ${reqUrl}`, `response body: ${JSON.stringify(body)}`].join('\n'),
+    );
+  }
+
+  const outputData = collectOutputData([
+    body.ip ?? '',
+    body?.continent ?? '',
+    body?.continent_code ?? '',
+    body?.country ?? '',
+    body?.country_code ?? '',
+    body?.flag?.emoji ?? '',
+    body?.region ?? '',
+    body?.region_code ?? '',
+    body?.city ?? '',
+    String(body?.connection?.asn ?? ''),
+    body?.connection?.org ?? '',
+    body?.connection?.isp ?? '',
+    body?.connection?.domain ?? '',
+  ]);
+
+  writeToMapCache(outputData, cacheMap, cacheMapMaxEntries);
+
+  await writeToFsCache(
+    body.ip ?? '',
+    outputData,
+    cacheDir,
+    cacheFileName,
+    cacheFileSeparator,
+    cacheFileNewline,
+  );
+
+  return outputData;
+};

package/app/cli.ts

@@ -0,0 +1,102 @@
+import chalk from 'chalk';
+
+import {
+  DEFAULT_CACHE_FILE_DIR,
+  DEFAULT_CACHE_FILE_NEWLINE,
+  DEFAULT_CACHE_FILE_SEPARATOR,
+  ip2geo,
+} from './api.ts';
+import {pruneCache} from './helpers/cache.ts';
+import {codeText, nameText} from './helpers/colors.ts';
+
+const {blue, red, green, dim, bold} = chalk;
+
+const args = process.argv.slice(2);
+const argsExtra = args.filter(arg => !arg.startsWith('-'));
+
+const isHelp = args.includes('-h') || args.includes('--help');
+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'),
+  );
+
+  process.exit(0);
+}
+
+if (isPrune) {
+  const cacheFolder = argsExtra[0] ?? DEFAULT_CACHE_FILE_DIR;
+  console.log(blue(cacheFolder));
+
+  try {
+    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'),
+    );
+
+    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(['', green(`Current cache entries: ${bold(entries)}`)].join('\n'));
+  } catch (err) {
+    console.error(red(String(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 flatten = output.flat();
+
+  if (args.includes('--json') || args.includes('-j')) {
+    console.log(JSON.stringify(flatten.length > 1 ? flatten : flatten[0]));
+  } else {
+    flatten.forEach(elem => console.log(elem));
+  }
+}

package/app/helpers/cache.ts

@@ -0,0 +1,257 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import _debug from 'debug';
+import {isIP} from 'is-ip';
+
+import type {ReqOutput} from '../types.ts';
+
+import {getArrayDups} from './utils.ts';
+
+const debug = _debug('mad:geoip');
+
+type CacheMap = Map<string, ReqOutput>;
+
+interface LongLinesFile {
+  file: string;
+  elem: string;
+}
+
+interface PruneCacheResult {
+  entries: number;
+  duplicates: string[];
+  different: string[];
+  empty: string[];
+  longLinesFiles: LongLinesFile[];
+}
+
+const outputKeys = [
+  'ip',
+  'continent',
+  'continentCode',
+  'country',
+  'countryCode',
+  'countryEmoji',
+  'region',
+  'regionCode',
+  'city',
+  'connectionAsn',
+  'connectionOrg',
+  'connectionIsp',
+  'connectionDomain',
+] as const;
+
+export const collectOutputData = (dataArr: string[]): ReqOutput => {
+  const outputData = {} as Record<(typeof outputKeys)[number], string | number | undefined>;
+
+  outputKeys.forEach((key, i) => {
+    outputData[key] = key === 'connectionAsn' && dataArr[i] ? Number(dataArr[i]) : dataArr[i];
+  });
+
+  return outputData as ReqOutput;
+};
+
+const getCacheFileFullPath = (ip: string, cacheDir: string, cacheFileName: string): string => {
+  const [firstOctet] = ip.split(/[.:]/);
+  return path.join(cacheDir, `${firstOctet}_${cacheFileName}`);
+};
+
+export const readFromFsCache = async (
+  ip: string,
+  cacheDir: string,
+  cacheFileName: string,
+  cacheFileSeparator: string,
+  cacheFileNewline: string,
+): Promise<ReqOutput | undefined> => {
+  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 as NodeJS.ErrnoException).code === 'ENOENT') {
+      await fs.appendFile(cacheFileFull, '');
+    } else {
+      throw err;
+    }
+  }
+
+  return undefined;
+};
+
+export const writeToFsCache = async (
+  ip: string,
+  data: ReqOutput,
+  cacheDir: string,
+  cacheFileName: string,
+  cacheFileSeparator: string,
+  cacheFileNewline: string,
+): Promise<void> => {
+  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),
+  );
+};
+
+export const readFromMapCache = (
+  ip: string,
+  cacheMap: CacheMap,
+  cacheMapMaxEntries: number,
+): ReqOutput | undefined => {
+  if (cacheMapMaxEntries > 0) {
+    const value = cacheMap.get(ip);
+
+    if (value) {
+      debug('get from map cache: %o', value);
+      return value;
+    }
+  }
+
+  return undefined;
+};
+
+export const removeFromMapCacheIfLimit = (cacheMap: CacheMap, cacheMapMaxEntries: number): void => {
+  if (cacheMap.size > cacheMapMaxEntries) {
+    debug('remove from map cache by limit: %o > %o', cacheMap.size, cacheMapMaxEntries);
+
+    for (const [key] of cacheMap) {
+      debug('remove from map cache by limit: %o', key);
+      cacheMap.delete(key);
+
+      if (cacheMap.size <= cacheMapMaxEntries) {
+        break;
+      }
+    }
+  }
+};
+
+export const writeToMapCache = (
+  body: ReqOutput,
+  cacheMap: CacheMap,
+  cacheMapMaxEntries: number,
+): void => {
+  if (cacheMapMaxEntries > 0) {
+    debug('set to map cache: %o', body);
+    cacheMap.set(body.ip ?? '', body);
+
+    removeFromMapCacheIfLimit(cacheMap, cacheMapMaxEntries);
+  }
+};
+
+export const pruneCache = async (
+  cacheDir: string,
+  cacheFileSeparator: string,
+  cacheFileNewline: string,
+): Promise<PruneCacheResult> => {
+  const files = await fs.readdir(cacheDir);
+
+  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 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: string): number =>
+    Number(
+      (line.split(cacheFileSeparator)[0] ?? '')
+        .split('.')
+        .map(num => `00${num}`.slice(-3))
+        .join(''),
+    );
+
+  const duplicates = new Set<string>();
+  const different = new Set<string>();
+  const empty: string[] = [];
+  const longLinesFiles = new Set<LongLinesFile>();
+  let entries = 0;
+
+  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 dataArrRemoveEmpty = dataArr.filter((elem): boolean => {
+        const splitted = elem.split(cacheFileSeparator);
+
+        if (splitted.length > outputKeys.length) {
+          longLinesFiles.add({file: fullFilePath, elem});
+        }
+
+        if (splitted.filter(Boolean).length > 1) {
+          return true;
+        }
+
+        empty.push(elem);
+        return false;
+      });
+
+      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]));
+
+      const removeDiffs = uniqSorted.filter(elem => {
+        if (dupsIp.includes(elem.split(cacheFileSeparator)[0])) {
+          different.add(elem);
+          return false;
+        }
+
+        return true;
+      });
+
+      const fileContent = removeDiffs.join(cacheFileNewline).trim();
+
+      if (fileContent) {
+        await fs.writeFile(fullFilePath, fileContent);
+        entries += removeDiffs.length;
+      } else {
+        await fs.rm(fullFilePath);
+      }
+    }),
+  );
+
+  return {
+    entries,
+    duplicates: [...duplicates],
+    different: [...different],
+    empty,
+    longLinesFiles: [...longLinesFiles],
+  };
+};

package/app/helpers/utils.ts

@@ -0,0 +1 @@
+export const getArrayDups = <T>(arr: T[]): T[] => arr.filter((e, i, a) => a.indexOf(e) !== i);

package/app/types.ts

@@ -0,0 +1,15 @@
+export interface ReqOutput {
+  ip?: string;
+  continent?: string;
+  continentCode?: string;
+  country?: string;
+  countryCode?: string;
+  countryEmoji?: string;
+  region?: string;
+  regionCode?: string;
+  city?: string;
+  connectionAsn?: number;
+  connectionOrg?: string;
+  connectionIsp?: string;
+  connectionDomain?: string;
+}

package/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node --import tsx
+
+import './app/cli.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k03mad/ip2geo",
-  "version": "19.3.3",
+  "version": "20.0.0",
   "description": "GeoIP library",
   "license": "MIT",
   "maintainers": [
@@ -11,27 +11,30 @@
     "url": "git+https://github.com/k03mad/ip2geo.git"
   },
   "bin": {
-    "ip2geo": "app/cli.js"
+    "ip2geo": "cli.js"
   },
   "type": "module",
-  "main": "app/api.js",
+  "main": "app/api.ts",
   "scripts": {
-    "lint": "oxlint && oxfmt -c node_modules/@k03mad/oxlint-config/.oxfmtrc.json --check",
-    "test": "rm -rfv ./.geoip && mocha tests --bail",
+    "lint": "oxlint && oxfmt -c node_modules/@k03mad/oxlint-config/.oxfmtrc.json --check && tsc --noEmit",
+    "test": "rm -rfv ./.geoip && node --test tests/*.ts",
     "prepare": "husky || true"
   },
   "dependencies": {
-    "@k03mad/request": "15.3.3",
     "chalk": "5.6.2",
     "debug": "4.4.3",
-    "is-ip": "5.0.1"
+    "is-ip": "5.0.1",
+    "tsx": "4.23.0"
   },
   "devDependencies": {
-    "@k03mad/oxlint-config": "0.9.3",
+    "@k03mad/oxlint-config": "0.11.0",
+    "@tsconfig/strictest": "2.0.8",
+    "@types/debug": "4.1.12",
+    "@types/node": "26.1.0",
     "husky": "9.1.7",
-    "mocha": "11.7.6",
-    "oxfmt": "0.53.0",
-    "oxlint": "1.68.0"
+    "oxfmt": "0.57.0",
+    "oxlint": "1.72.0",
+    "typescript": "6.0.3"
   },
   "engines": {
     "node": ">=24"

package/pnpm-workspace.yaml

@@ -1,43 +1,5 @@
+allowBuilds:
+  esbuild: false
 minimumReleaseAgeExclude:
-  - '@k03mad/oxlint-config@0.9.3'
-  - '@k03mad/request@15.3.3'
-  - '@oxfmt/binding-android-arm-eabi@0.53.0'
-  - '@oxfmt/binding-android-arm64@0.53.0'
-  - '@oxfmt/binding-darwin-arm64@0.53.0'
-  - '@oxfmt/binding-darwin-x64@0.53.0'
-  - '@oxfmt/binding-freebsd-x64@0.53.0'
-  - '@oxfmt/binding-linux-arm-gnueabihf@0.53.0'
-  - '@oxfmt/binding-linux-arm-musleabihf@0.53.0'
-  - '@oxfmt/binding-linux-arm64-gnu@0.53.0'
-  - '@oxfmt/binding-linux-arm64-musl@0.53.0'
-  - '@oxfmt/binding-linux-ppc64-gnu@0.53.0'
-  - '@oxfmt/binding-linux-riscv64-gnu@0.53.0'
-  - '@oxfmt/binding-linux-riscv64-musl@0.53.0'
-  - '@oxfmt/binding-linux-s390x-gnu@0.53.0'
-  - '@oxfmt/binding-linux-x64-gnu@0.53.0'
-  - '@oxfmt/binding-linux-x64-musl@0.53.0'
-  - '@oxfmt/binding-openharmony-arm64@0.53.0'
-  - '@oxfmt/binding-win32-arm64-msvc@0.53.0'
-  - '@oxfmt/binding-win32-ia32-msvc@0.53.0'
-  - '@oxfmt/binding-win32-x64-msvc@0.53.0'
-  - '@oxlint/binding-android-arm-eabi@1.68.0'
-  - '@oxlint/binding-android-arm64@1.68.0'
-  - '@oxlint/binding-darwin-arm64@1.68.0'
-  - '@oxlint/binding-darwin-x64@1.68.0'
-  - '@oxlint/binding-freebsd-x64@1.68.0'
-  - '@oxlint/binding-linux-arm-gnueabihf@1.68.0'
-  - '@oxlint/binding-linux-arm-musleabihf@1.68.0'
-  - '@oxlint/binding-linux-arm64-gnu@1.68.0'
-  - '@oxlint/binding-linux-arm64-musl@1.68.0'
-  - '@oxlint/binding-linux-ppc64-gnu@1.68.0'
-  - '@oxlint/binding-linux-riscv64-gnu@1.68.0'
-  - '@oxlint/binding-linux-riscv64-musl@1.68.0'
-  - '@oxlint/binding-linux-s390x-gnu@1.68.0'
-  - '@oxlint/binding-linux-x64-gnu@1.68.0'
-  - '@oxlint/binding-linux-x64-musl@1.68.0'
-  - '@oxlint/binding-openharmony-arm64@1.68.0'
-  - '@oxlint/binding-win32-arm64-msvc@1.68.0'
-  - '@oxlint/binding-win32-ia32-msvc@1.68.0'
-  - '@oxlint/binding-win32-x64-msvc@1.68.0'
-  - oxfmt@0.53.0
-  - oxlint@1.68.0
+  - '@k03mad/oxlint-config@0.11.0'
+  - tsx@4.23.0

package/tests/cache-file-entries.ts

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import {describe, it} from 'node:test';
+
+import {ip2geo} from '../app/api.ts';
+import type {ReqOutput} from '../app/types.ts';
+
+import {getCurrentFilename, getTestFolder} from './helpers/path.ts';
+import {REQUEST_IPV4} from './shared/consts.ts';
+import {checkCacheFile, removeCacheFolder} from './shared/fs.ts';
+
+const testName = getCurrentFilename(import.meta.url);
+
+describe(testName, () => {
+  const opts = {
+    cacheDir: getTestFolder(testName),
+    cacheMap: new Map<string, ReqOutput>(),
+    cacheMapMaxEntries: 0,
+    tries: 5,
+  };
+
+  it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
+
+  Array.from({length: opts.tries}, (_, i) => i + 1).forEach(num => {
+    describe(`Try: ${num}`, () => {
+      it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
+        const data = await ip2geo({ip: REQUEST_IPV4.ip ?? '', ...opts});
+        assert.deepEqual(data, REQUEST_IPV4);
+      });
+
+      it('should have cache file', () =>
+        checkCacheFile({
+          ...opts,
+          response: REQUEST_IPV4,
+        }));
+    });
+  });
+});

package/tests/cache-file-modify.ts

@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict';
+import {describe, it} from 'node:test';
+
+import {ip2geo} from '../app/api.ts';
+import type {ReqOutput} from '../app/types.ts';
+
+import {getCurrentFilename, getTestFolder} from './helpers/path.ts';
+import {REQUEST_IPV4} from './shared/consts.ts';
+import {checkCacheFile, removeCacheFolder} from './shared/fs.ts';
+
+const testName = getCurrentFilename(import.meta.url);
+
+describe(testName, () => {
+  const opts = {
+    cacheDir: getTestFolder(testName),
+    cacheFileName: 'ips.md',
+    cacheFileSeparator: '-_-',
+    cacheFileNewline: '%%%',
+    cacheMap: new Map<string, ReqOutput>(),
+  };
+
+  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({ip: REQUEST_IPV4.ip ?? '', ...opts});
+    assert.deepEqual(data, REQUEST_IPV4);
+  });
+
+  it('should have cache file', () =>
+    checkCacheFile({
+      ...opts,
+      response: REQUEST_IPV4,
+    }));
+});