@k03mad/ip2geo 19.3.3 → 20.0.0

package/app/helpers/cache.js

@@ -1,274 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-import _debug from 'debug';
-import {isIP} from 'is-ip';
-
-import {getArrayDups} from './utils.js';
-
-const debug = _debug('mad:geoip');
-
-const outputKeys = [
-    'ip',
-    'continent',
-    'continentCode',
-    'country',
-    'countryCode',
-    'countryEmoji',
-    'region',
-    'regionCode',
-    'city',
-    'connectionAsn',
-    'connectionOrg',
-    'connectionIsp',
-    'connectionDomain',
-];
-
-/**
- * @param {string[]} dataArr
- * @returns {object}
- */
-export const collectOutputData = dataArr => {
-    const outputData = {};
-
-    outputKeys.forEach((key, i) => {
-        outputData[key] = key === 'connectionAsn' && dataArr[i] ? Number(dataArr[i]) : 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);
-    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),
-    );
-};
-
-/**
- * @param {string} ip
- * @param {Map} cacheMap
- * @param {number} cacheMapMaxEntries
- * @returns {object | undefined}
- */
-export const readFromMapCache = (ip, cacheMap, cacheMapMaxEntries) => {
-    if (cacheMapMaxEntries > 0) {
-        const value = cacheMap.get(ip);
-
-        if (value) {
-            debug('get from map cache: %o', value);
-            return value;
-        }
-    }
-};
-
-/**
- * @param {Map} cacheMap
- * @param {number} cacheMapMaxEntries
- */
-export const removeFromMapCacheIfLimit = (cacheMap, cacheMapMaxEntries) => {
-    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;
-            }
-        }
-    }
-};
-
-/**
- * @param {object} body
- * @param {string} body.ip
- * @param {Map} cacheMap
- * @param {number} cacheMapMaxEntries
- */
-export const writeToMapCache = (body, cacheMap, cacheMapMaxEntries) => {
-    if (cacheMapMaxEntries > 0) {
-        debug('set to map cache: %o', body);
-        cacheMap.set(body.ip, body);
-
-        removeFromMapCacheIfLimit(cacheMap, cacheMapMaxEntries);
-    }
-};
-
-/**
- * @param {string} cacheDir
- * @param {string} cacheFileSeparator
- * @param {string} cacheFileNewline
- */
-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);
-
-            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 =>
-        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);
-
-            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);
-
-                if (splitted.length > outputKeys.length) {
-                    longLinesFiles.add({file: fullFilePath, elem});
-                }
-
-                if (splitted.filter(Boolean).length > 1) {
-                    return true;
-                }
-
-                empty.push(elem);
-            });
-
-            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.js

@@ -1,2 +0,0 @@
-/** @param {Array} arr */
-export const getArrayDups = arr => arr.filter((e, i, a) => a.indexOf(e) !== i);

package/tests/cache-file-entries.js

@@ -1,37 +0,0 @@
-import assert from 'node:assert/strict';
-
-import {describe, it} from 'mocha';
-
-import {ip2geo} from '../app/api.js';
-
-import {getCurrentFilename, getTestFolder} from './helpers/path.js';
-import {REQUEST_IPV4} from './shared/consts.js';
-import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
-
-const testName = getCurrentFilename(import.meta.url);
-
-describe(testName, () => {
-    const opts = {
-        cacheDir: getTestFolder(testName),
-        cacheMap: new Map(),
-        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.js

@@ -1,34 +0,0 @@
-import assert from 'node:assert/strict';
-
-import {describe, it} from 'mocha';
-
-import {ip2geo} from '../app/api.js';
-
-import {getCurrentFilename, getTestFolder} from './helpers/path.js';
-import {REQUEST_IPV4} from './shared/consts.js';
-import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
-
-const testName = getCurrentFilename(import.meta.url);
-
-describe(testName, () => {
-    const opts = {
-        cacheDir: getTestFolder(testName),
-        cacheFileName: 'ips.md',
-        cacheFileSeparator: '-_-',
-        cacheFileNewline: '%%%',
-        cacheMap: new Map(),
-    };
-
-    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,
-        }));
-});

package/tests/cache-file-subfolder.js

@@ -1,34 +0,0 @@
-import assert from 'node:assert/strict';
-import path from 'node:path';
-
-import {describe, it} from 'mocha';
-
-import {ip2geo} from '../app/api.js';
-
-import {getCurrentFilename, getTestFolder} from './helpers/path.js';
-import {REQUEST_IPV4} from './shared/consts.js';
-import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
-
-const testName = getCurrentFilename(import.meta.url);
-
-describe(testName, () => {
-    const SUBFOLDERS = 5;
-
-    const opts = {
-        cacheDir: getTestFolder(path.join(...Array.from({length: SUBFOLDERS}, () => testName))),
-        cacheMap: new Map(),
-    };
-
-    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,
-        }));
-});

package/tests/cache-map-entries.js

@@ -1,41 +0,0 @@
-import assert from 'node:assert/strict';
-
-import {describe, it} from 'mocha';
-
-import {ip2geo} from '../app/api.js';
-
-import {getCurrentFilename, getTestFolder} from './helpers/path.js';
-import {REQUEST_IPV4, REQUEST_IPV6} from './shared/consts.js';
-import {removeCacheFolder} from './shared/fs.js';
-
-const testName = getCurrentFilename(import.meta.url);
-
-describe(testName, () => {
-    const opts = {
-        cacheDir: getTestFolder(testName),
-        cacheMap: new Map(),
-    };
-
-    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 1 correct cache entry', () => {
-        assert.equal(opts.cacheMap.size, 1);
-        assert.deepEqual(opts.cacheMap.get(REQUEST_IPV4.ip), REQUEST_IPV4);
-    });
-
-    it.skip(`should return correct response for IP: "${REQUEST_IPV6.ip}"`, async () => {
-        const data = await ip2geo({ip: REQUEST_IPV6.ip, ...opts});
-        assert.deepEqual(data, REQUEST_IPV6);
-    });
-
-    it.skip('should have 2 correct cache entries', () => {
-        assert.equal(opts.cacheMap.size, 2);
-        assert.deepEqual(opts.cacheMap.get(REQUEST_IPV4.ip), REQUEST_IPV4);
-        assert.deepEqual(opts.cacheMap.get(REQUEST_IPV6.ip), REQUEST_IPV6);
-    });
-});

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

@@ -1,50 +0,0 @@
-import assert from 'node:assert/strict';
-
-import {describe, it} from 'mocha';
-
-import {ip2geo} from '../app/api.js';
-
-import {getCurrentFilename, getTestFolder} from './helpers/path.js';
-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 secondReqIps = ['60.60.60.60'];
-
-    const opts = {
-        cacheDir: getTestFolder(testName),
-        cacheMap: new Map(),
-        cacheMapMaxEntries: 2,
-    };
-
-    it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
-
-    firstReqIps.forEach(ip => {
-        it(`should request geo for IP: "${ip}"`, async () => {
-            await ip2geo({ip, ...opts});
-        });
-    });
-
-    it(`should have ${opts.cacheMapMaxEntries} correct cache entries`, () => {
-        assert.equal(opts.cacheMap.size, opts.cacheMapMaxEntries);
-        assert.deepEqual([...opts.cacheMap.keys()], firstReqIps.slice(-opts.cacheMapMaxEntries));
-    });
-
-    secondReqIps.forEach(ip => {
-        it(`should request geo for IP: "${ip}"`, async () => {
-            await ip2geo({ip, ...opts});
-        });
-    });
-
-    it(`should have ${opts.cacheMapMaxEntries} correct cache entries`, () => {
-        assert.equal(opts.cacheMap.size, opts.cacheMapMaxEntries);
-
-        assert.deepEqual(
-            [...opts.cacheMap.keys()],
-            [firstReqIps, secondReqIps].flat().slice(-opts.cacheMapMaxEntries),
-        );
-    });
-});

package/tests/cache-map-off.js

@@ -1,35 +0,0 @@
-import assert from 'node:assert/strict';
-
-import {describe, it} from 'mocha';
-
-import {cacheStorage, ip2geo} from '../app/api.js';
-
-import {getCurrentFilename, getTestFolder} from './helpers/path.js';
-import {REQUEST_IPV4_MAP_OFF_ONLY} from './shared/consts.js';
-import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
-
-const testName = getCurrentFilename(import.meta.url);
-
-describe(testName, () => {
-    const opts = {
-        cacheDir: getTestFolder(testName),
-        cacheMapMaxEntries: 0,
-    };
-
-    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({ip: REQUEST_IPV4_MAP_OFF_ONLY.ip, ...opts});
-        assert.deepEqual(data, 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

@@ -1,55 +0,0 @@
-import assert from 'node:assert/strict';
-
-import {describe, it} from 'mocha';
-
-import {cacheStorage, ip2geo} from '../app/api.js';
-
-import {getCurrentFilename} from './helpers/path.js';
-import {REQUEST_IPV4} from './shared/consts.js';
-import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
-
-const testName = getCurrentFilename(import.meta.url);
-
-describe(testName, () => {
-    it('should remove fs cache dir if exist', () => removeCacheFolder());
-
-    describe('with ip arg', () => {
-        it(`should return correct response for IP: "${REQUEST_IPV4.ip}"`, async () => {
-            const data = await ip2geo({ip: REQUEST_IPV4.ip});
-            assert.deepEqual(data, REQUEST_IPV4);
-        });
-
-        it('should have cache file', () =>
-            checkCacheFile({
-                response: REQUEST_IPV4,
-            }));
-
-        it('should have 1 correct cache entry', () => {
-            assert.equal(cacheStorage.size, 1);
-            assert.deepEqual(cacheStorage.get(REQUEST_IPV4.ip), REQUEST_IPV4);
-        });
-    });
-
-    describe('without ip arg', () => {
-        let data;
-
-        it('should request geoip without ip arg', async () => {
-            data = await ip2geo();
-        });
-
-        Object.keys(REQUEST_IPV4).forEach(key => {
-            it(`should have "${key}" in request response`, () => {
-                assert.ok(Object.hasOwn(data, key));
-            });
-        });
-
-        it('should not have extra keys in request response', () => {
-            assert.deepEqual(Object.keys(data), Object.keys(REQUEST_IPV4));
-        });
-
-        it('should have 2 cache entries', () => {
-            assert.equal(cacheStorage.size, 2);
-            assert.deepEqual(cacheStorage.get(REQUEST_IPV4.ip), REQUEST_IPV4);
-        });
-    });
-});

package/tests/helpers/path.js

@@ -1,13 +0,0 @@
-import path from 'node:path';
-
-/**
- * @param {string} file Import.meta.url
- * @returns {string}
- */
-export const getCurrentFilename = file => path.basename(file, '.js');
-
-/**
- * @param {string} file
- * @returns {string}
- */
-export const getTestFolder = file => path.join('.geoip', file);

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

@@ -1,39 +0,0 @@
-import assert from 'node:assert/strict';
-
-import {describe, it} from 'mocha';
-
-import {ip2geo} from '../app/api.js';
-
-import {getCurrentFilename, getTestFolder} from './helpers/path.js';
-import {REQUEST_IPV4} from './shared/consts.js';
-import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
-
-const testName = getCurrentFilename(import.meta.url);
-
-describe(testName, () => {
-    const opts = {
-        cacheDir: getTestFolder(testName),
-        cacheMap: new Map(),
-        requestsCount: 5,
-    };
-
-    it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
-
-    Array.from({length: opts.requestsCount}).forEach(() => {
-        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,
-        }));
-
-    it('should have 1 correct cache entry', () => {
-        assert.equal(opts.cacheMap.size, 1);
-        assert.deepEqual(opts.cacheMap.get(REQUEST_IPV4.ip), REQUEST_IPV4);
-    });
-});

package/tests/ip-no-data.js

@@ -1,35 +0,0 @@
-import assert from 'node:assert/strict';
-
-import {describe, it} from 'mocha';
-
-import {ip2geo} from '../app/api.js';
-
-import {getCurrentFilename, getTestFolder} from './helpers/path.js';
-import {REQUEST_IPV4} from './shared/consts.js';
-import {removeCacheFolder} from './shared/fs.js';
-
-const testName = getCurrentFilename(import.meta.url);
-
-describe(testName, () => {
-    const responses = [{ip: '10.10.10.10'}, {ip: '192.168.1.100'}];
-
-    const opts = {
-        cacheDir: getTestFolder(testName),
-        cacheMap: new Map(),
-    };
-
-    it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
-
-    responses.forEach(response => {
-        Object.keys(REQUEST_IPV4).forEach(elem => {
-            if (elem !== 'ip') {
-                response[elem] = undefined;
-            }
-        });
-
-        it(`should return empty response for IP: "${response.ip}"`, async () => {
-            const data = await ip2geo({ip: response.ip, ...opts});
-            assert.deepEqual(data, response);
-        });
-    });
-});

package/tests/ip-v6.js

@@ -1,31 +0,0 @@
-import assert from 'node:assert/strict';
-
-import {describe, it} from 'mocha';
-
-import {ip2geo} from '../app/api.js';
-
-import {getCurrentFilename, getTestFolder} from './helpers/path.js';
-import {REQUEST_IPV6} from './shared/consts.js';
-import {checkCacheFile, removeCacheFolder} from './shared/fs.js';
-
-const testName = getCurrentFilename(import.meta.url);
-
-describe.skip(testName, () => {
-    const opts = {
-        cacheDir: getTestFolder(testName),
-        cacheMap: new Map(),
-    };
-
-    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({ip: REQUEST_IPV6.ip, ...opts});
-        assert.deepEqual(data, REQUEST_IPV6);
-    });
-
-    it('should have cache file', () =>
-        checkCacheFile({
-            ...opts,
-            response: REQUEST_IPV6,
-        }));
-});