@k03mad/ip2geo 1.0.0

package/.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.json]
+indent_size = 2

package/.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"

package/.github/workflows/lint.yml

@@ -0,0 +1,32 @@
+name: Lint
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+  schedule:
+    - cron: '00 15 * * 6'
+
+jobs:
+  lint:
+    name: Lint
+    permissions:
+      contents: read
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install NodeJS
+        uses: actions/setup-node@v4
+        with:
+          node-version-file: '.nvmrc'
+
+      - name: Run setup
+        run: npm run setup
+
+      - name: Run lint
+        run: npm run lint

package/.github/workflows/test.yml

@@ -0,0 +1,32 @@
+name: Test
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+  schedule:
+    - cron: '00 15 * * 6'
+
+jobs:
+  test:
+    name: Test
+    permissions:
+      contents: read
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install NodeJS
+        uses: actions/setup-node@v4
+        with:
+          node-version-file: '.nvmrc'
+
+      - name: Run setup
+        run: npm run setup
+
+      - name: Run test
+        run: npm run test

package/.husky/pre-commit

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

package/.nvmrc

@@ -0,0 +1 @@
+20

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "eslint.experimental.useFlatConfig": true
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Kirill Molchanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+# GeoIP lookup
+
+— Using [ipwhois.io](https://ipwhois.io/documentation) \
+— Runtime cache \
+— Filesystem infinity cache
+
+## API
+
+```bash
+npm i @k03mad/ip2geo --save-exact
+echo "/geoip" >> .gitignore
+```
+
+```js
+import {ip2geo} from '@k03mad/ip2geo';
+
+const {
+    ip,
+    emoji,
+    country,
+    countryA2,
+    city,
+    isp,
+} = await ip2geo('1.1.1.1', {
+    // defaults
+    cacheDir: 'geoip',
+    cacheFileName: 'ip.log',
+    cacheFileSeparator: ';;',
+    cacheFileNewline: '\n',
+});
+
+// ip: "1.1.1.1"
+// emoji: "🇺🇸"
+// country: "United States"
+// countryA2: "US"
+// city: "Washington"
+// isp: "Cloudflare, Inc."
+```

package/app/index.js

@@ -0,0 +1 @@
+export {default as ip2geo} from './lib/ip2geo.js';

package/app/lib/ip2geo.js

@@ -0,0 +1,164 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import {request} from '@k03mad/request';
+import _debug from 'debug';
+
+const debug = _debug('mad:geoip');
+
+/**
+ * @typedef {object} GeoIpOutput
+ * @property {string} [ip]
+ * @property {string} [emoji]
+ * @property {string} [country]
+ * @property {string} [countryA2]
+ * @property {string} [city]
+ * @property {string} [isp]
+ */
+
+const API = 'https://ipwho.is/';
+
+const CACHE_FILE_DIR = 'geoip';
+const CACHE_FILE_NAME = 'ip.log';
+const CACHE_FILE_SEPARATOR = ';;';
+const CACHE_FILE_NEWLINE = '\n';
+
+const cacheMap = new Map();
+
+const outputKeys = [
+    'ip',
+    'emoji',
+    'country',
+    'countryA2',
+    'city',
+    'isp',
+];
+
+/**
+ * @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>}
+ */
+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]
+ * @returns {Promise<GeoIpOutput>}
+ */
+export default async (ip = '', {
+    cacheDir = CACHE_FILE_DIR,
+    cacheFileName = CACHE_FILE_NAME,
+    cacheFileSeparator = CACHE_FILE_SEPARATOR,
+    cacheFileNewline = CACHE_FILE_NEWLINE,
+} = {}) => {
+    if (ip) {
+        const ipData = cacheMap.get(ip);
+
+        if (ipData) {
+            debug('get from map cache: %o', ipData);
+            return ipData;
+        }
+
+        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);
+
+                    cacheMap.set(ip, outputData);
+                    return outputData;
+                }
+            }
+        }
+    }
+
+    const {body} = await request(API + ip);
+
+    const usedData = [
+        body.ip,
+        body?.flag?.emoji,
+        body?.country,
+        body?.country_code,
+        body?.city,
+        body?.connection?.isp,
+    ];
+
+    const outputData = collectOutputData(usedData);
+
+    cacheMap.set(body.ip, outputData);
+    debug('set to map cache: %o', outputData);
+
+    await writeToFsCache(
+        body.ip, usedData,
+        cacheDir, cacheFileName, cacheFileSeparator, cacheFileNewline,
+    );
+
+    debug('set to fs cache: %o', outputData);
+    return outputData;
+};

package/eslint.config.js

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

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@k03mad/ip2geo",
+  "version": "1.0.0",
+  "description": "GeoIP library",
+  "maintainers": [
+    "Kirill Molchanov <k03.mad@gmail.com"
+  ],
+  "main": "app/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/k03mad/ip2geo.git"
+  },
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@k03mad/request": "5.4.1",
+    "debug": "4.3.4"
+  },
+  "devDependencies": {
+    "@k03mad/eslint-config": "19.2.0",
+    "eslint": "8.56.0",
+    "husky": "8.0.3"
+  },
+  "scripts": {
+    "lint": "npm run lint:eslint",
+    "lint:eslint": "eslint ./ --cache",
+    "test": "node --test tests/*",
+    "clean": "npm run clean:modules && npm run clean:eslint:cache",
+    "clean:modules": "rm -rf ./node_modules || true",
+    "clean:eslint:cache": "rm -rf .eslintcache || true",
+    "setup": "npm run clean && npm i",
+    "prepare": "husky install || true"
+  }
+}

package/tests/opts-assigned-subfolder.js

@@ -0,0 +1,44 @@
+import assert from 'node:assert/strict';
+import {describe, it} from 'node:test';
+
+import {ip2geo} from '../app/index.js';
+
+import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
+
+describe('opts-assigned', () => {
+    const CACHE_FILE_DIR = 'geoip-subfolder/hello_there';
+    const CACHE_FILE_NAME = 'ip.log';
+    const CACHE_FILE_SEPARATOR = ';;';
+    const CACHE_FILE_NEWLINE = '\n';
+
+    const REQUEST_IP = '9.9.9.9';
+
+    const cacheFile = `${REQUEST_IP.split('.')[0]}_${CACHE_FILE_NAME}`;
+
+    const response = {
+        ip: REQUEST_IP,
+        emoji: '🇨🇭',
+        country: 'Switzerland',
+        countryA2: 'CH',
+        city: 'Zürich',
+        isp: 'Quad9',
+    };
+
+    removeCacheFolder(CACHE_FILE_DIR);
+
+    it(`should return correct response for IP: "${REQUEST_IP}"`, async () => {
+        const data = await ip2geo(REQUEST_IP, {
+            cacheDir: CACHE_FILE_DIR,
+        });
+
+        assert.deepEqual(data, response);
+    });
+
+    checkCacheFile(
+        CACHE_FILE_DIR,
+        cacheFile,
+        CACHE_FILE_SEPARATOR,
+        CACHE_FILE_NEWLINE,
+        response,
+    );
+});

package/tests/opts-assigned.js

@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict';
+import {describe, it} from 'node:test';
+
+import {ip2geo} from '../app/index.js';
+
+import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
+
+describe('opts-assigned', () => {
+    const CACHE_FILE_DIR = 'geoip-cache-opts';
+    const CACHE_FILE_NAME = 'ips.md';
+    const CACHE_FILE_SEPARATOR = '-_-';
+    const CACHE_FILE_NEWLINE = '%%%';
+
+    const REQUEST_IP = '8.8.8.8';
+
+    const cacheFile = `${REQUEST_IP.split('.')[0]}_${CACHE_FILE_NAME}`;
+
+    const response = {
+        ip: REQUEST_IP,
+        emoji: '🇺🇸',
+        country: 'United States',
+        countryA2: 'US',
+        city: 'Mountain View',
+        isp: 'Google LLC',
+    };
+
+    removeCacheFolder(CACHE_FILE_DIR);
+
+    it(`should return correct response for IP: "${REQUEST_IP}"`, async () => {
+        const data = await ip2geo(REQUEST_IP, {
+            cacheDir: CACHE_FILE_DIR,
+            cacheFileName: CACHE_FILE_NAME,
+            cacheFileSeparator: CACHE_FILE_SEPARATOR,
+            cacheFileNewline: CACHE_FILE_NEWLINE,
+        });
+
+        assert.deepEqual(data, response);
+    });
+
+    checkCacheFile(
+        CACHE_FILE_DIR,
+        cacheFile,
+        CACHE_FILE_SEPARATOR,
+        CACHE_FILE_NEWLINE,
+        response,
+    );
+});

package/tests/opts-default.js

@@ -0,0 +1,67 @@
+import assert from 'node:assert/strict';
+import {describe, it} from 'node:test';
+
+import {ip2geo} from '../app/index.js';
+
+import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
+
+describe('opts-default', () => {
+    const CACHE_FILE_DIR = 'geoip';
+    const CACHE_FILE_NAME = 'ip.log';
+    const CACHE_FILE_SEPARATOR = ';;';
+    const CACHE_FILE_NEWLINE = '\n';
+
+    const REQUEST_IP = '1.1.1.1';
+
+    const cacheFile = `${REQUEST_IP.split('.')[0]}_${CACHE_FILE_NAME}`;
+
+    const response = {
+        ip: REQUEST_IP,
+        emoji: '🇺🇸',
+        country: 'United States',
+        countryA2: 'US',
+        city: 'Washington',
+        isp: 'Cloudflare, Inc.',
+    };
+
+    const outputKeys = [
+        'ip',
+        'emoji',
+        'country',
+        'countryA2',
+        'city',
+        'isp',
+    ];
+
+    removeCacheFolder(CACHE_FILE_DIR);
+
+    describe('with ip arg', () => {
+        it(`should return correct response for IP: "${REQUEST_IP}"`, async () => {
+            const data = await ip2geo(REQUEST_IP);
+
+            assert.deepEqual(data, response);
+        });
+
+        checkCacheFile(
+            CACHE_FILE_DIR,
+            cacheFile,
+            CACHE_FILE_SEPARATOR,
+            CACHE_FILE_NEWLINE,
+            response,
+        );
+    });
+
+    describe('without ip arg', () => {
+        let data;
+
+        it('should request geoip without ip arg', async () => {
+            data = await ip2geo();
+        });
+
+        outputKeys.forEach(key => {
+            it(`should have "${key}" in request response`, () => {
+                assert.ok(data[key]);
+            });
+        });
+    });
+});

package/tests/shared/fs.js

@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {it} from 'node:test';
+
+/**
+ * @param {string} cacheDir
+ */
+export const removeCacheFolder = cacheDir => {
+    it('should remove fs cache dir if exist', async () => {
+        try {
+            await fs.rm(cacheDir, {recursive: true, force: true});
+        } catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
+        }
+    });
+};
+
+/**
+ * @param {string} cacheDir
+ * @param {string} cacheFileName
+ * @param {string} cacheFileSeparator
+ * @param {string} cacheFileNewline
+ * @param {object} response
+ */
+export const checkCacheFile = (cacheDir, cacheFileName, cacheFileSeparator, cacheFileNewline, response) => {
+    it('should have cache file', async () => {
+        const data = await fs.readFile(path.join(cacheDir, cacheFileName), {encoding: 'utf8'});
+
+        assert.equal(data, Object.values(response).join(cacheFileSeparator) + cacheFileNewline);
+    });
+};