@k03mad/ip2geo 4.2.1 → 5.0.0

package/.github/workflows/lint.yml

@@ -25,6 +25,9 @@ jobs:
         with:
           node-version-file: '.nvmrc'
 
+      - name: Install PNPM
+        run: npm i pnpm -g
+
       - name: Run setup
         run: npm run setup
 

package/.github/workflows/test.yml

@@ -25,6 +25,9 @@ jobs:
         with:
           node-version-file: '.nvmrc'
 
+      - name: Install PNPM
+        run: npm i pnpm -g
+
       - name: Run setup
         run: npm run setup
 

package/README.md

@@ -45,7 +45,8 @@ const info = await ip2geo('1.1.1.1', {
     cacheFileSeparator: ';;',
     cacheFileNewline: '\n',
     cacheMap: new Map(),
-    rps: 3, // useful in Promise.all with IPs array
+    cacheMapMaxEntries: Number.POSITIVE_INFINITY, // store last N requests, 0 — turns cache map off
+    rps: 3, // API RPS, useful in Promise.all with IPs array
 });
 
 // info {

package/app/lib/ip2geo.js

@@ -26,6 +26,7 @@ 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();
@@ -111,8 +112,9 @@ const writeToFsCache = async (ip, data, cacheDir, cacheFileName, cacheFileSepara
  * @param {string} [opts.cacheFileName]
  * @param {string} [opts.cacheFileSeparator]
  * @param {string} [opts.cacheFileNewline]
- * @param {Map} [opts.cacheMap]
- * @param {number} opts.rps
+ * @param {Map|false} [opts.cacheMap]
+ * @param {number} [opts.cacheMapMaxEntries]
+ * @param {number} [opts.rps]
  * @returns {Promise<GeoIpOutput>}
  */
 export const ip2geo = async (ip = '', {
@@ -120,15 +122,18 @@ export const ip2geo = async (ip = '', {
     cacheFileName = DEFAULT_CACHE_FILE_NAME,
     cacheFileSeparator = DEFAULT_CACHE_FILE_SEPARATOR,
     cacheFileNewline = DEFAULT_CACHE_FILE_NEWLINE,
+    cacheMapMaxEntries = DEFAULT_CACHE_MAP_MAX_ENTRIES,
     cacheMap = cacheStorage,
     rps = DEFAULT_RPS,
 } = {}) => {
     if (ip) {
-        const ipData = cacheMap.get(ip);
+        if (cacheMapMaxEntries > 0) {
+            const ipData = cacheMap.get(ip);
 
-        if (ipData) {
-            debug('get from map cache: %o', ipData);
-            return ipData;
+            if (ipData) {
+                debug('get from map cache: %o', ipData);
+                return ipData;
+            }
         }
 
         const fsCache = await readFromFsCache(ip, cacheDir, cacheFileName);
@@ -143,7 +148,11 @@ export const ip2geo = async (ip = '', {
                     const outputData = collectOutputData(fileData);
                     debug('get from fs cache: %o', outputData);
 
-                    cacheMap.set(ip, outputData);
+                    if (cacheMapMaxEntries > 0) {
+                        cacheMap.set(ip, outputData);
+                        debug('set to map cache: %o', outputData);
+                    }
+
                     return outputData;
                 }
             }
@@ -170,8 +179,10 @@ export const ip2geo = async (ip = '', {
 
     const outputData = collectOutputData(usedData);
 
-    cacheMap.set(body.ip, outputData);
-    debug('set to map cache: %o', outputData);
+    if (cacheMapMaxEntries > 0) {
+        cacheMap.set(body.ip, outputData);
+        debug('set to map cache: %o', outputData);
+    }
 
     await writeToFsCache(
         body.ip, usedData,
@@ -179,5 +190,19 @@ export const ip2geo = async (ip = '', {
     );
 
     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": "4.2.1",
+  "version": "5.0.0",
   "description": "GeoIP library",
   "maintainers": [
     "Kirill Molchanov <k03.mad@gmail.com"
@@ -25,7 +25,7 @@
     "debug": "4.3.4"
   },
   "devDependencies": {
-    "@k03mad/eslint-config": "19.4.0",
+    "@k03mad/eslint-config": "19.5.0",
     "eslint": "8.56.0",
     "husky": "8.0.3",
     "mocha": "10.2.0"
@@ -37,7 +37,7 @@
     "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",
+    "setup": "npm run clean && pnpm i",
     "prepare": "husky install || true"
   }
 }

package/tests/{opts-assigned-cache-map.js → cache-map-entries.js}

@@ -11,11 +11,9 @@ import {removeCacheFolder} from './shared/fs.js';
 const testName = getCurrentFilename(import.meta.url);
 
 describe(testName, () => {
-    const cacheMap = new Map();
-
     const opts = {
         cacheDir: getTestFolder(testName),
-        cacheMap,
+        cacheMap: new Map(),
     };
 
     it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
@@ -26,8 +24,8 @@ describe(testName, () => {
     });
 
     it('should have 1 correct cache entry', () => {
-        assert.equal(cacheMap.size, 1);
-        assert.deepEqual(cacheMap.get(REQUEST_IPV4.ip), REQUEST_IPV4);
+        assert.equal(opts.cacheMap.size, 1);
+        assert.deepEqual(opts.cacheMap.get(REQUEST_IPV4.ip), REQUEST_IPV4);
     });
 
     it(`should return correct response for IP: "${REQUEST_IPV6.ip}"`, async () => {
@@ -36,8 +34,8 @@ describe(testName, () => {
     });
 
     it('should have 2 correct cache entries', () => {
-        assert.equal(cacheMap.size, 2);
-        assert.deepEqual(cacheMap.get(REQUEST_IPV4.ip), REQUEST_IPV4);
-        assert.deepEqual(cacheMap.get(REQUEST_IPV6.ip), REQUEST_IPV6);
+        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

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict';
+
+import {describe, it} from 'mocha';
+
+import {ip2geo} from '../app/index.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

@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+
+import {describe, it} from 'mocha';
+
+import {cacheStorage, ip2geo} from '../app/index.js';
+
+import {REQUEST_IPV4} from './helpers/consts.js';
+import {getCurrentFilename, getTestFolder} from './helpers/path.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.ip}"`, async () => {
+        const data = await ip2geo(REQUEST_IPV4.ip, opts);
+        assert.deepEqual(data, REQUEST_IPV4);
+    });
+
+    it('should have cache file', () => checkCacheFile({
+        response: REQUEST_IPV4,
+    }));
+
+    it('should not have cache entries', () => {
+        assert.equal(cacheStorage.size, 0);
+    });
+});

package/tests/{opts-assigned-multi-requests.js → ip-multi-requests-cache.js}

@@ -30,4 +30,9 @@ describe(testName, () => {
         ...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/{opts-assigned-no-data.js → ip-no-data.js}

@@ -11,13 +11,10 @@ import {removeCacheFolder} from './shared/fs.js';
 const testName = getCurrentFilename(import.meta.url);
 
 describe(testName, () => {
-    const response = {ip: '10.10.10.10'};
-
-    Object.keys(REQUEST_IPV4).forEach(elem => {
-        if (elem !== 'ip') {
-            response[elem] = undefined;
-        }
-    });
+    const responses = [
+        {ip: '10.10.10.10'},
+        {ip: 'test'},
+    ];
 
     const opts = {
         cacheDir: getTestFolder(testName),
@@ -26,8 +23,16 @@ describe(testName, () => {
 
     it('should remove fs cache dir if exist', () => removeCacheFolder(opts.cacheDir));
 
-    it(`should return empty response for IP: "${response.ip}"`, async () => {
-        const data = await ip2geo(response.ip, opts);
-        assert.deepEqual(data, response);
+    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(response.ip, opts);
+            assert.deepEqual(data, response);
+        });
     });
 });

package/tests/{opts-assigned-ipv6.js → ip-v6.js}

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