Merge pull request #14 from ConnerTechnology/update_cache

Make cache configurable and cache bulk lookup responses

Author: thomasconner

package-lock.json

@@ -2,7 +2,7 @@
   "name": "ipdata",
   "version": "2.0.0",
   "description": "JavaScript library to gather information for an ip using https://ipdata.co.",
-  "main": "./lib/index.js",
+  "main": "./lib/ipdata.js",
   "scripts": {
     "prebuild": "del lib",
     "build": "tsc",
@@ -24,7 +24,7 @@
     "is-ip": "^3.1.0",
     "lodash": "4.17.15",
     "lru-cache": "5.1.1",
-    "tslib": "1.9.3",
+    "tslib": "1.10.0",
     "url-join": "4.0.0"
   },
   "devDependencies": {

package.json

@@ -7,7 +7,6 @@ import LRU from 'lru-cache';
 
 const CACHE_MAX = 4096; // max number of items
 const CACHE_MAX_AGE = 1000 * 60 * 60 * 24; // 24 hours
-const cache = new LRU<string, LookupResponse>({ max: CACHE_MAX, maxAge: CACHE_MAX_AGE });
 const DEFAULT_IP = 'DEFAULT_IP';
 const VALID_FIELDS = [
   'ip',
@@ -67,12 +66,10 @@ function isValidFields(fields: string[]): boolean {
   return true;
 }
 
-// export function clearCache(ip?: string): void {
-//   if (isValidIP(ip)) {
-//     return cache.del(ip);
-//   }
-//   return cache.reset();
-// }
+export interface CacheConfig {
+  max?: number;
+  maxAge?: number;
+}
 
 export interface LookupResponse {
   ip: string;
@@ -139,15 +136,15 @@ interface IPDataParams {
 
 export default class IPData {
   apiKey?: string;
-  useCache?: boolean;
+  cache?: LRU<string, LookupResponse>;
 
-  constructor(apiKey: string, useCache = true) {
+  constructor(apiKey: string, cacheConfig?: CacheConfig) {
     if (!isString(apiKey)) {
       throw new Error('An API key is required.');
     }
 
     this.apiKey = apiKey;
-    this.useCache = useCache === true;
+    this.cache = new LRU<string, LookupResponse>({ max: CACHE_MAX, maxAge: CACHE_MAX_AGE, ...cacheConfig });
   }
 
   async lookup(ip?: string, selectField?: string, fields?: string[]): Promise<LookupResponse> {
@@ -158,8 +155,8 @@ export default class IPData {
       throw new Error(`${ip} is an invalid IP address.`);
     }
 
-    if (this.useCache && cache.has(ip || DEFAULT_IP)) {
-      return cache.get(ip || DEFAULT_IP);
+    if (this.cache.has(ip || DEFAULT_IP)) {
+      return this.cache.get(ip || DEFAULT_IP);
     }
 
     if (selectField && fields) {
@@ -182,11 +179,7 @@ export default class IPData {
         data = { [selectField]: response.data, status: response.status };
       }
 
-      if ((!selectField || !fields) && this.useCache) {
-        cache.set(ip || DEFAULT_IP, data);
-      } else {
-        return data;
-      }
+      this.cache.set(ip || DEFAULT_IP, data);
     } catch (e) {
       const { response } = e as AxiosError;
       if (response) {
@@ -195,11 +188,13 @@ export default class IPData {
       throw e;
     }
 
-    return cache.get(ip || DEFAULT_IP);
+    return this.cache.get(ip || DEFAULT_IP);
   }
 
   async bulkLookup(ips: string[], fields?: string[]): Promise<BulkLookupResponse> {
     const params: IPDataParams = { 'api-key': this.apiKey };
+    const responses: LookupResponse[] = [];
+    const bulk = [];
 
     if (ips.length < 2) {
       throw new Error('Bulk Lookup requires more than 1 IP Address in the payload.');
@@ -209,15 +204,30 @@ export default class IPData {
       if (!isValidIP(ip)) {
         throw new Error(`${ip} is an invalid IP address.`);
       }
+
+      if (this.cache.has(ip)) {
+        responses.push(this.cache.get(ip));
+      } else {
+        bulk.push(ip);
+      }
     });
 
     if (fields && isValidFields(fields)) {
       params.fields = fields.join(',');
     }
 
     try {
-      const response = await axios.post(urljoin(BASE_URL, 'bulk'), ips, { params });
-      return { responses: response.data, status: response.status };
+      let result: BulkLookupResponse = { responses, status: 200 };
+
+      if (bulk.length > 0) {
+        const response = await axios.post(urljoin(BASE_URL, 'bulk'), bulk, { params });
+        response.data.forEach(info => {
+          this.cache.set(info.ip, info);
+        });
+        result = { responses: [...responses, ...response.data], status: response.status };
+      }
+
+      return result;
     } catch (e) {
       const { response } = e as AxiosError;
       if (response) {

src/ipdata.ts

@@ -4,6 +4,7 @@ const API_KEY = 'test';
 
 describe('constructor()', () => {
   it('should throw an error if an apiKey is not provided', () => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
     // @ts-ignore
     expect(() => new IPData()).toThrowError('An API key is required.');
   });
@@ -12,28 +13,22 @@ describe('constructor()', () => {
     const ipdata = new IPData(API_KEY);
     expect(ipdata.apiKey).toEqual(API_KEY);
   });
-
-  it('should turn on the cache by default', () => {
-    const ipdata = new IPData(API_KEY);
-    expect(ipdata.useCache).toEqual(true);
-  });
-
-  it('should turn off the cache', () => {
-    const ipdata = new IPData(API_KEY, false);
-    expect(ipdata.useCache).toEqual(false);
-  });
 })
 
 describe('lookup()', () => {
-  const ipdata = new IPData(API_KEY, false);
+  const ipdata = new IPData(API_KEY);
   const IP = '1.1.1.1';
 
-  it('should throw an error if the ip is invalid', async () => {
+  afterEach(() => {
+    return ipdata.cache.reset();
+  });
+
+  it('should throw an error if the ip address is invalid', async () => {
     const badIP = '1.1.11';
     await expect(ipdata.lookup(badIP)).rejects.toThrowError(`${badIP} is an invalid IP address.`);
   });
 
-  it('should return default information when no ip is provided', async () => {
+  it('should return default information when no ip address is provided', async () => {
     const info = await ipdata.lookup();
     expect(info).toHaveProperty('ip');
     expect(info).toHaveProperty('status');
@@ -51,12 +46,26 @@ describe('lookup()', () => {
     expect(info).toHaveProperty('status');
   });
 
-  it('should set an ip in the uri', async () => {
+  it('should cache the ip address info for the default ip address', async () => {
+    await ipdata.lookup();
+    const info = ipdata.cache.get('DEFAULT_IP');
+    expect(info).toHaveProperty('ip');
+    expect(info).toHaveProperty('status');
+  });
+
+  it('should accept an ip address', async () => {
     const info = await ipdata.lookup(IP);
     expect(info).toHaveProperty('ip', IP);
     expect(info).toHaveProperty('status');
   });
 
+  it('should cache the ip address info', async () => {
+    await ipdata.lookup(IP);
+    const info = ipdata.cache.get(IP);
+    expect(info).toHaveProperty('ip', IP);
+    expect(info).toHaveProperty('status');
+  });
+
   it('should throw an error if a selectField and fields is provided', async () => {
     await expect(ipdata.lookup(null, 'field', ['field'])).rejects.toThrowError(
       'The selectField and fields parameters cannot be used at the same time.',
@@ -97,24 +106,28 @@ describe('lookup()', () => {
 });
 
 describe('bulkLookup()', () => {
-  const ipdata = new IPData(API_KEY, false);
+  const ipdata = new IPData(API_KEY);
   const IP1 = '1.1.1.1';
   const IP2 = '8.8.8.8';
 
-  it('should throw an error if less than 2 ips are provided', async () => {
+  afterEach(() => {
+    return ipdata.cache.reset();
+  });
+
+  it('should throw an error if less than 2 ip addresses are provided', async () => {
     const ips = [IP1];
     await expect(ipdata.bulkLookup(ips)).rejects.toThrowError(
       'Bulk Lookup requires more than 1 IP Address in the payload.',
     );
   });
 
-  it('should throw an error if an ip is invalid', async () => {
+  it('should throw an error if an ip address is invalid', async () => {
     const badIP = '1.1.11';
     const ips = [badIP, IP2];
     await expect(ipdata.bulkLookup(ips)).rejects.toThrowError(`${badIP} is an invalid IP address.`);
   });
 
-  it('should return info for the ips', async () => {
+  it('should return info for the ip addresses', async () => {
     const info = await ipdata.bulkLookup([IP1, IP2]);
     expect(info).toHaveProperty('responses');
     expect(info).toHaveProperty('status');

test/ipdata.test.ts

@@ -12,6 +12,7 @@
     "target": "es5"
   },
   "include": [
-    "src/**/*"
+    "src/**/*",
+    "test/**/*"
   ]
 }