ac-geoip 1.4.2

package/.acsemver.js

@@ -0,0 +1,9 @@
+module.exports = {
+  repository: {
+    url: 'https://github.com/admiralcloud/ac-geoip'
+  },
+  changelogFile: __dirname + '/CHANGELOG.md',
+  sections: [
+    {name: 'App' }
+  ],
+}

package/.eslintrc.js

@@ -0,0 +1,27 @@
+const config = {
+  root: true,
+  'env': {
+    'commonjs': true,
+    'es6': true,
+    'node': true
+  },
+  'extends': 'eslint:recommended',
+  "rules": {
+    "space-before-function-paren": 0,
+    "no-extra-semi": 0,
+    "object-curly-spacing": ["error", "always"],
+    "brace-style": ["error", "stroustrup", { "allowSingleLine": true }],
+    "no-useless-escape": 0,
+    "standard/no-callback-literal": 0,
+    "new-cap": 0
+  },
+  globals: {
+    describe: true,
+    it: true
+  },
+  'parserOptions': {
+    'ecmaVersion': 2018
+},
+}
+
+module.exports = config

package/CHANGELOG.md

@@ -0,0 +1,154 @@
+<a name="1.4.2"></a>
+
+## [1.4.2](https://github.com/admiralcloud/ac-geoip/compare/v1.4.1..v1.4.2) (2021-10-09 10:25:40)
+
+
+### Bug Fix
+
+* **App:** Package updates | MP | [08dd237ecc7274cfb083f3f6279036fa94d17398](https://github.com/admiralcloud/ac-geoip/commit/08dd237ecc7274cfb083f3f6279036fa94d17398)    
+Package updates
+<a name="1.4.1"></a>
+
+## [1.4.1](https://github.com/mmpro/ac-geoip/compare/v1.4.0..v1.4.1) (2021-05-02 09:42:55)
+
+
+### Bug Fix
+
+* **App:** Improved debug log | MP | [e5985e0a10d08979ab2f1ddadcc51217f43e0342](https://github.com/mmpro/ac-geoip/commit/e5985e0a10d08979ab2f1ddadcc51217f43e0342)    
+Improved debug log
+### Tests
+
+* **App:** Minor fix | MP | [42f5ffec32d0fa9d54306ddc1281feef7ef6e3df](https://github.com/mmpro/ac-geoip/commit/42f5ffec32d0fa9d54306ddc1281feef7ef6e3df)    
+Minor fix
+### Chores
+
+* **App:** Updated packages | MP | [39b1e855d0d8b7419868f84038163f142f5a4b26](https://github.com/mmpro/ac-geoip/commit/39b1e855d0d8b7419868f84038163f142f5a4b26)    
+Updated packages
+<a name="1.4.0"></a>
+ 
+# [1.4.0](https://github.com/mmpro/ac-geoip/compare/v1.3.0..v1.4.0) (2021-04-12 09:36:41)
+
+
+### Feature
+
+* **App:** Use node-cache per default | MP | [1a5481a30245fc53ccb6333a60f4ae38a8245eb5](https://github.com/mmpro/ac-geoip/commit/1a5481a30245fc53ccb6333a60f4ae38a8245eb5)    
+If Redis is not defined, use node-cache (memory) to improve performance.
+### Bug Fix
+
+* **App:** Allow Redis usage when using local database | MP | [943ab0cf914245cceab0c23da1e03078783a1b66](https://github.com/mmpro/ac-geoip/commit/943ab0cf914245cceab0c23da1e03078783a1b66)    
+To improve performance it makes sense to use Redis even for local database. Lookup is a little slow and consumes a lot of CPU
+<a name="1.3.0"></a>
+ 
+# [1.3.0](https://github.com/mmpro/ac-geoip/compare/v1.2.1..v1.3.0) (2021-04-02 09:52:27)
+
+
+### Feature
+
+* **App:** LookupLocal for local database lookup | MP | [d6821229d6475e6bd2bb83822bee01bf474f1219](https://github.com/mmpro/ac-geoip/commit/d6821229d6475e6bd2bb83822bee01bf474f1219)    
+LookupLocal is now available as dedicated function to lookup a local geolite database. Lookup only uses webservice. You can use both functions in parallel (e.g. to compare results).
+<a name="1.2.1"></a>
+
+## [1.2.1](https://github.com/mmpro/ac-geoip/compare/v1.2.0..v1.2.1) (2021-04-02 06:49:54)
+
+
+### Bug Fix
+
+* **App:** Improved logging | MP | [7d664460d4109fc078e656a0fe264a23c7e2cf9d](https://github.com/mmpro/ac-geoip/commit/7d664460d4109fc078e656a0fe264a23c7e2cf9d)    
+Improved logging
+### Tests
+
+* **App:** Added tests for geolite database | MP | [f6da987068a63c4cb43fb84729e4816875de9283](https://github.com/mmpro/ac-geoip/commit/f6da987068a63c4cb43fb84729e4816875de9283)    
+Added tests for geolite database
+### Chores
+
+* **App:** Updated packages | MP | [66e8056c2dab7377b6040cb35551ee3bf352e98d](https://github.com/mmpro/ac-geoip/commit/66e8056c2dab7377b6040cb35551ee3bf352e98d)    
+Updated packages
+<a name="1.2.0"></a>
+ 
+# [1.2.0](https://github.com/mmpro/ac-geoip/compare/v1.1.0..v1.2.0) (2021-03-21 07:35:20)
+
+
+### Feature
+
+* **App:** You can now use geolite2 local database | MP | [dd671ab0b6bcc19cee5aefeb3cf421c15974e864](https://github.com/mmpro/ac-geoip/commit/dd671ab0b6bcc19cee5aefeb3cf421c15974e864)    
+It is now possible to use geolite2 downloadble database instead of web service.
+### Chores
+
+* **App:** Do not commit folder geolite2 | MP | [8e20cbba069222d9f25abe79111d604bc827b3e6](https://github.com/mmpro/ac-geoip/commit/8e20cbba069222d9f25abe79111d604bc827b3e6)    
+Do not commit folder geolite2
+### Chores
+
+* **App:** Updated packages | MP | [8c44382bb0f0c60973fccd6f7e25feb01993e32b](https://github.com/mmpro/ac-geoip/commit/8c44382bb0f0c60973fccd6f7e25feb01993e32b)    
+Updated packages
+<a name="1.1.0"></a>
+ 
+# [1.1.0](https://github.com/mmpro/ac-geoip/compare/v1.0.4..v1.1.0) (2020-12-12 14:43:41)
+
+
+### Feature
+
+* **App:** Function now supports async/await | MP | [f6b65c568ed34fb8149ee9e00d23b8946cb83256](https://github.com/mmpro/ac-geoip/commit/f6b65c568ed34fb8149ee9e00d23b8946cb83256)    
+You can use async/await in addition to classic callback
+### Chores
+
+* **App:** Remove husky | MP | [cb52b5d3f8c38c6e8a9437725b5aeba35cf6de33](https://github.com/mmpro/ac-geoip/commit/cb52b5d3f8c38c6e8a9437725b5aeba35cf6de33)    
+Remove husky
+* **App:** Package cleanup and updates | MP | [f661f118bd7897bce87de6c862d8497a19ec72f8](https://github.com/mmpro/ac-geoip/commit/f661f118bd7897bce87de6c862d8497a19ec72f8)    
+Package cleanup and updates
+* **App:** Use ac-semantic-release | MP | [66c9797b3db0072559d62f16dcaa93acdad6859a](https://github.com/mmpro/ac-geoip/commit/66c9797b3db0072559d62f16dcaa93acdad6859a)    
+Use ac-semantic-release
+<a name="1.0.4"></a>
+## [1.0.4](https://github.com/mmpro/ac-geoip/compare/v1.0.3...v1.0.4) (2019-10-13 06:40)
+
+
+### Bug Fixes
+
+* **GeoIP:** Only log if debug parameter is set | MP ([b5466de](https://github.com/mmpro/ac-geoip/commit/b5466de))    
+  Only log if debug parameter is set
+
+
+
+<a name="1.0.3"></a>
+## [1.0.3](https://github.com/mmpro/ac-geoip/compare/v1.0.2...v1.0.3) (2019-10-06 09:57)
+
+
+### Bug Fixes
+
+* **GeoIP:** Minor fixes: Redis, debugging | MP ([d692f62](https://github.com/mmpro/ac-geoip/commit/d692f62))    
+  Fixed using Redis, added debug option per request
+
+
+
+<a name="1.0.2"></a>
+## [1.0.2](https://github.com/mmpro/ac-geoip/compare/v1.0.1...v1.0.2) (2019-10-06 09:10)
+
+
+### Bug Fixes
+
+* **GeoIP:** Improved functionality | MP ([000654f](https://github.com/mmpro/ac-geoip/commit/000654f))    
+  Check for private IP, fixed using Redis as cache, allow mapping per request.
+
+
+
+<a name="1.0.1"></a>
+## [1.0.1](https://github.com/mmpro/ac-geoip/compare/v1.0.0...v1.0.1) (2019-10-03 11:09)
+
+
+### Bug Fixes
+
+* **GeoIP:** Removed location from default mapping | MP ([6c25ed4](https://github.com/mmpro/ac-geoip/commit/6c25ed4))    
+  Removed location from default mapping
+
+
+
+<a name="1.0.0"></a>
+# 1.0.0 (2019-10-03 08:36)
+
+
+### Features
+
+* **GeoIP:** Initial version | MP ([89771ac](https://github.com/mmpro/ac-geoip/commit/89771ac))    
+  Initial version
+
+
+

package/Makefile

@@ -0,0 +1,16 @@
+MOCHA_OPTS= --slow 0 -A
+REPORTER = spec
+
+lint-fix:
+	./node_modules/.bin/eslint --fix index.js test/test.js
+
+lint-check:
+	./node_modules/.bin/eslint index.js test/test.js
+
+commit:
+	@node ./node_modules/ac-semantic-release/lib/commit.js
+
+release:
+	@node ./node_modules/ac-semantic-release/lib/release.js
+	
+.PHONY: check

package/README.md

@@ -0,0 +1,118 @@
+# AC GEOIP
+Lookup IP addresses at Maxmind GEOIP services or local Maxmind (Geolite) database and prepare the response with custom field mapping. Optionally, you can store the response in Redis to improve performance (of your app).
+
+GEOIP web service requires an account at Maxmind.
+
+You can also use the Geolite2 database from Maxmind: https://dev.maxmind.com/geoip/geoip2/geolite2/
+
+## Usage
+
+### Using Webservice
+```
+const acgeoip = require('./index')
+
+let geoip = {
+  userId: 123456778,
+  licenseKey: 'abc-licensekey'
+}
+acgeoip.init(geoip)
+
+// ASYNC/AWAIT
+async() {
+  let response = await acgeoip.lookup({ ip: '1.2.3.4' })
+}
+```
+
+### Using local (Geolite) database
+```
+const acgeoip = require('./index')
+
+let geoip = {
+  geolite: {
+    enabled: true,
+    path: '/path/to/GeoLite2-City.mmdb'
+  }
+}
+acgeoip.init(geoip)
+
+// ASYNC/AWAIT
+async() {
+  let response = await acgeoip.lookupLocal({ ip: '1.2.3.4' })
+}
+```
+
+### Combined usage
+```
+const acgeoip = require('./index')
+
+let geoip = {
+  userId: 123456778,
+  licenseKey: 'abc-licensekey',
+  geolite: {
+    enabled: true,
+    path: '/path/to/GeoLite2-City.mmdb'
+  }
+}
+acgeoip.init(geoip)
+
+// lookup using web service
+async() {
+  let response = await acgeoip.lookup({ ip: '1.2.3.4' })
+}
+
+// lookup using local database
+async() {
+  let response = await acgeoip.lookupLocal({ ip: '1.2.3.4' })
+}
+```
+
+### Using callbacks
+We recommend using modern async/await approach, but you can also use classic callbacks.
+```
+// TRADITONAL CALLBACK is available for lookup and lookupLocal 
+acgeoip.lookup({
+  ip: '8.8.8.8'
+}, (err, response) => {
+  console.log(response)
+})
+
+```
+
+## Init Parameters
+**Required**   
+Initiate the function with the required "userId" and "licenseKey" if you want to use the webservice. If you want to use local database, make sure to set geolite.enabled to true and provide the location of the database.
+
+**Mapping**   
+Define how your response looks like using a mapping array. The array contains objects with properties "response" which is the property name in the response and "geoIP" which is the path to the GeoIP response. 
+
+See this default setup as example
+```
+ mapping: [
+      { response: 'iso2', geoIP: 'country.iso_code' },
+      { response: 'city', geoIP: 'city.names.en' },
+      { response: 'region', geoIP: 'subdivisions[0].names.en' },
+      // the following properties are only available using the paid webservice
+      { response: 'isp', geoIP: 'traits.isp' },
+      { response: 'organization', geoIP: 'traits.organization' },
+      { response: 'domain', geoIP: 'traits.domain' },
+      { response: 'location', geoIP: 'location' },
+    ]
+```
+
+**Caching**   
+In order to cache the data, you need to provide:
++ redis - a redis instance (from ioredis)
++ environment - prefix (default development) for the redisKey (e.g development:geoip:8.8.8.8)
++ cacheTime - seconds to cache the GeoIP response (default 7 days)
+
+
+## Links
+- [Website](https://www.admiralcloud.com/)
+- [Twitter (@admiralcloud)](https://twitter.com/admiralcloud)
+- [Facebook](https://www.facebook.com/MediaAssetManagement/)
+
+## Thanks
+Thanks to https://github.com/maxmind/GeoIP2-node
+
+## License
+[MIT License](https://opensource.org/licenses/MIT) Copyright © 2009-present, AdmiralCloud AG, Mark Poepping

package/index.js

@@ -0,0 +1,289 @@
+const _ = require('lodash')
+const ipPackage = require('ip')
+const fs = require('fs')
+
+const WebServiceClient = require('@maxmind/geoip2-node').WebServiceClient;
+const Reader = require('@maxmind/geoip2-node').Reader;
+
+const NodeCache = require( "node-cache" );
+const geoCache = new NodeCache( { stdTTL: 7*86400, checkperiod: 3600 } );
+
+const acgeoip = () => {
+  
+  let geoip = {
+    userId: 'userId',
+    licenseKey: 'licenseKey',
+    environment: 'development',
+    // redis, // instance of redis
+    // reader // initiated if useBuffer with local database
+    geolite: {
+      useBuffer: false,
+      enabled: false,
+      path: '/path/to/GeoLite2-City.mmdb'
+    },
+    cacheTime: 7 * 86400, // cache GEOIP response for 1 week
+    mapping: [
+      { response: 'iso2', geoIP: 'country.isoCode' },
+      { response: 'city', geoIP: 'city.names.en' },
+      { response: 'region', geoIP: 'subdivisions[0].names.en' },
+      { response: 'isp', geoIP: 'traits.isp' },
+      { response: 'organization', geoIP: 'traits.organization' },
+      { response: 'domain', geoIP: 'traits.domain' },
+      { response: 'latitude', geoIP: 'location.latitude' },
+      { response: 'longitude', geoIP: 'location.longitude' }
+    ]
+  }
+
+  const init = (params) => {
+    if (_.has(params, 'userId')) _.set(geoip, 'userId', _.get(params, 'userId'))
+    if (_.has(params, 'licenseKey')) _.set(geoip, 'licenseKey', _.get(params, 'licenseKey'))
+    if (_.has(params, 'env')) _.set(geoip, 'environment', _.get(params, 'env'))
+    if (_.has(params, 'redis')) _.set(geoip, 'redis', _.get(params, 'redis'))
+    if (_.has(params, 'geolite')) _.set(geoip, 'geolite', _.get(params, 'geolite'))
+
+    if (_.get(params, 'geolite.enabled') && _.get(params, 'geolite.useBuffer')) {
+      const dbBuffer = fs.readFileSync(_.get(geoip, 'geolite.path'))
+      geoip.reader = Reader.openBuffer(dbBuffer)
+    }
+  }
+
+
+
+  const lookupLocal = async(params, cb) => {
+    const functionName = 'ac-geoip | lookupLocal'
+    if (!_.get(geoip, 'geolite.enabled')) {
+      let message = 'acgeoip_geolite_notEnabled'
+      if (_.isFunction(cb)) return cb({ message })
+      throw Error(message)
+    }
+    const ip = _.get(params, 'ip')
+    if (ipPackage.isPrivate(ip)) {
+      if (_.isFunction(cb)) return cb()
+      return
+    }
+
+    const mapping = _.get(params, 'mapping', geoip.mapping)
+    const debug = _.get(params, 'debug')
+    const debugPerformance = _.get(params, 'debugPerforance')
+    const start = process.hrtime()
+
+    let response = {
+      ip
+    }
+    let geoipResponse
+
+    if (geoip.redis) {
+      geoipResponse = await checkRedis(params)
+    }
+    else {
+      geoipResponse = getFromMemory({ ip })
+    }
+    if (debugPerformance) console.log('%s | getFromCache %d', functionName, performanceHelper(start, process.hrtime()))
+
+    if (!geoipResponse) {
+      if (_.get(geoip, 'geolite.useBuffer') && geoip.reader) {
+        geoipResponse = geoip.reader.city(ip)
+        if (debugPerformance) console.log('%s | readFromBuffer %d', functionName, performanceHelper(start, process.hrtime()))
+      }
+      else {
+        try {
+          if (_.get(geoip, 'geolite.enabled')) {
+            geoipResponse = await new Promise((resolve, reject) => {
+                Reader.open(_.get(geoip, 'geolite.path')).then(reader => {
+                const response = reader.city(ip)
+                resolve(response)
+              }).catch(reject)
+            })
+          }
+          if (debugPerformance) console.log('%s | readFromDB %d', functionName, performanceHelper(start, process.hrtime()))
+
+          if (debug) {
+            console.log('AC-GEOIP | From Geolite | %j', geoipResponse)
+          }
+        }
+        catch(e) {
+          console.error('AC-GEOIP | From Geolite | Failed | %j', e)
+        }
+      }
+      if (geoipResponse) {
+        _.set(geoipResponse, 'origin', 'db')
+        if (geoip.redis) {
+          await storeRedis({ ip, geoipResponse })  
+        }
+        else {
+          storeInMemory({ ip, geoipResponse })          
+        }
+        if (debugPerformance) console.log('%s | storeInCache %d', functionName, performanceHelper(start, process.hrtime()))
+      }
+    }
+
+    // prepare response
+    if (!_.isEmpty(mapping)) {
+      _.forEach(mapping, item => {
+        if (_.get(geoipResponse, item.geoIP)) _.set(response, item.response, _.get(geoipResponse, item.geoIP))
+      })
+    }
+    else {
+      response = geoipResponse
+    }
+    _.set(response, 'origin', _.get(geoipResponse, 'origin'))
+    if (_.get(geoipResponse, 'fromCache')) _.set(response, 'fromCache', true)
+
+    if (debugPerformance) console.log('%s | Finished %d', functionName, performanceHelper(start, process.hrtime()))
+    if (_.isFunction(cb)) return cb(null, response)
+    return response
+  }
+
+  const lookup = async(params, cb) => {
+    const functionName = 'ac-geoip | lookup'
+    if (!_.get(geoip, 'licenseKey') || _.get(geoip, 'licenseKey') === 'licenseKey') {
+      let message = 'acgeoip_licenseKey_missing'
+      if (_.isFunction(cb)) return cb({ message })
+      throw Error(message)
+    }
+    const ip = _.get(params, 'ip')
+    if (ipPackage.isPrivate(ip)) {
+      if (_.isFunction(cb)) return cb()
+      return
+    }
+
+    const mapping = _.get(params, 'mapping', geoip.mapping)
+    const debug = _.get(params, 'debug')
+    const debugPerformance = _.get(params, 'debugPerforance')
+    const start = process.hrtime()
+    
+    let response = {
+      ip
+    }
+    let geoipResponse
+
+    if (geoip.redis) {
+      geoipResponse = await checkRedis(params)
+    }
+    else {
+      geoipResponse = getFromMemory({ ip })
+    }
+    if (debugPerformance) console.log('%s | getFromCache %d', functionName, performanceHelper(start, process.hrtime()))
+
+    // fetch fresh
+    if (!_.get(geoipResponse, 'country')) {
+      try {
+        const client = new WebServiceClient(geoip.userId, geoip.licenseKey)
+        geoipResponse = await new Promise((resolve, reject) => {
+            client.city(ip).then(result => {
+              return resolve(result)
+          }).catch(reject)
+        })
+        if (debugPerformance) console.log('%s | readFromWebservice %d', functionName, performanceHelper(start, process.hrtime()))
+        if (geoipResponse) {
+          _.set(geoipResponse, 'origin', 'webservice')
+        }
+
+        if (debug) {
+          console.log('AC-GEOIP | From Maxmind | %j', geoipResponse)
+        }
+      }
+      catch(e) {
+        console.error('AC-GEOIP | From Maxmind | Failed | %j', e)
+      }
+    }
+
+    if (geoipResponse) {
+      if (geoip.redis) {
+        await storeRedis({ ip, geoipResponse })  
+      }
+      else {
+        storeInMemory({ ip, geoipResponse })          
+      }
+      if (debugPerformance) console.log('%s | storeInCache %d', functionName, performanceHelper(start, process.hrtime()))
+    }
+
+    // prepare response
+    if (!_.isEmpty(mapping)) {
+      _.forEach(mapping, item => {
+        if (_.get(geoipResponse, item.geoIP)) _.set(response, item.response, _.get(geoipResponse, item.geoIP))
+      })
+    }
+    else {
+      response = geoipResponse
+    }
+
+    _.set(response, 'origin', _.get(geoipResponse, 'origin'))
+    if (_.get(geoipResponse, 'fromCache')) _.set(response, 'fromCache', true)
+
+    if (_.isFunction(cb)) return cb(null, response)
+    return response
+  }
+
+  const storeInMemory = (params) => {
+    const geoipResponse = _.get(params, 'geoipResponse')
+    const ip = _.get(params, 'ip')
+    const storageKey = _.get(geoip, 'environment') + ':geoip:' + ip
+    geoCache.set(storageKey, geoipResponse)
+  }
+
+  const getFromMemory = (params) => {
+    const ip = _.get(params, 'ip')
+    const storageKey = _.get(geoip, 'environment') + ':geoip:' + ip
+    return geoCache.get(storageKey)
+  }
+
+
+  const checkRedis = async(params, cb) => {
+    const refresh = _.get(params, 'refresh')
+    if (!geoip.redis || refresh) {
+      if (_.isFunction(cb)) return cb()
+      return
+    }
+    const ip = _.get(params, 'ip')
+    const redisKey = _.get(geoip, 'environment') + ':geoip:' + ip
+    const debug = _.get(params, 'debug')
+
+    let geoipResponse
+    try {
+      geoipResponse = await geoip.redis.get(redisKey)
+      geoipResponse = JSON.parse(geoipResponse)
+      if (_.isPlainObject(geoipResponse)) {
+        geoipResponse.fromCache = true
+      }
+      if (debug) {
+        console.log('AC-GEOIP | From Cache | %j', geoipResponse)
+      }
+    }
+    catch(e) {
+      console.log(e)
+      console.error('AC-GEOIP | From Cache | Failed | %j', e)
+    }
+    return geoipResponse
+  }
+
+  const storeRedis = async(params) => {
+    const refresh = _.get(params, 'refresh')
+    if (!geoip.redis || refresh) {
+      return
+    }
+    const ip = _.get(params, 'ip')
+    const geoipResponse = _.get(params, 'geoipResponse')
+    const redisKey = _.get(geoip, 'environment') + ':geoip:' + ip
+
+    await geoip.redis.setex(redisKey, geoip.cacheTime, JSON.stringify(geoipResponse))
+  }
+
+  const performanceHelper = (t1, t2, options) => {
+    const accuracy = _.get(options, 'accuracy', 1e6)
+    const s = t2[0] - t1[0]
+    const mms = t2[1] - t1[1]
+    return (s*1e9 + mms)/accuracy
+  }
+
+
+  return {
+    init,
+    lookup,
+    lookupLocal
+  }
+}
+
+module.exports = acgeoip()
+
+

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "ac-geoip",
+  "author": "Mark Poepping (https://www.admiralcloud.com)",
+  "license": "MIT",
+  "repository": "admiralcloud/ac-geoip",
+  "version": "1.4.2",
+  "dependencies": {
+    "@maxmind/geoip2-node": "^3.2.0",
+    "ip": "^1.1.5",
+    "lodash": "^4.17.21",
+    "node-cache": "^5.1.2"
+  },
+  "devDependencies": {
+    "ac-semantic-release": "^0.2.6",
+    "chai": "^4.3.4",
+    "eslint": "^7.32.0",
+    "ioredis": "^4.27.10",
+    "mocha": "^9.1.2"
+  },
+  "scripts": {
+    "test": "./node_modules/.bin/mocha --bail --exit --slow 1000 ./test/test.js || :"
+  },
+  "engines": {
+    "node": ">=8.0.0"
+  }
+}

package/test/test.js

@@ -0,0 +1,133 @@
+const acgeoip = require('../index')
+const _ = require('lodash')
+
+const { expect } = require('chai');
+
+
+
+const Redis = require("ioredis");
+const redis = new Redis() 
+
+const credentials = require('./../credentials');
+
+
+const ip = '35.184.130.59'
+const expectedValue = {
+  ip: '35.184.130.59',
+  iso2: 'US',
+  city: 'Council Bluffs',
+  region: 'Iowa',
+  isp: 'Google Cloud',
+  organization: 'Google Cloud',
+  domain: 'googleusercontent.com'
+}
+
+
+
+describe('Test Webservice', () => {
+
+  it('Webservice is not yet enabled - should fail', async function() {
+    this.timeout(5000)
+    try {
+      await acgeoip.lookup({ ip, debug: false })    
+    }
+    catch (e) {
+      expect(e).to.be.instanceOf(Error)
+      expect(e.message).to.eql('acgeoip_licenseKey_missing')
+    }
+  })
+
+  it('Init', done => {
+    const geoip = {
+      redis,
+      userId: credentials.userId,
+      licenseKey: credentials.licenseKey
+    }
+    acgeoip.init(geoip)
+    return done()
+  })
+
+  it('Shoud be tested with async/await', async function() {
+    this.timeout(5000)
+    const result = await acgeoip.lookup({ ip, debug: false, refresh: true })     
+    _.forOwn(expectedValue, (val, key) => {
+      expect(result).to.have.property(key, val)
+    })
+    return
+  })
+
+  it('Shoud be tested with async/await - should be from cache', async function() {
+    this.timeout(5000)
+    const result = await acgeoip.lookup({ ip, debug: false })
+    _.forOwn(expectedValue, (val, key) => {
+      expect(result).to.have.property(key, val)
+    })
+    expect(result).to.have.property('fromCache', true)
+    return
+  })
+
+  it('End', done => {
+    return done()
+  })
+})
+
+
+describe('Test Geolite2 local database', () => {
+
+  it('Geolite local is not yet enabled - should fail', async function() {
+    this.timeout(5000)
+    try {
+      await acgeoip.lookupLocal({ ip, debug: false })    
+    }
+ catch (e) {
+      expect(e).to.be.instanceOf(Error)
+      expect(e.message).to.eql('acgeoip_geolite_notEnabled')
+    }
+  })
+
+  it('Init geolite', done => {
+    const geoip = {
+      redis,
+      userId: undefined,
+      licenseKey: undefined,
+      geolite: {
+        enabled: true,
+        path: './geolite2/GeoLite2-City.mmdb'
+      }
+    }
+    acgeoip.init(geoip)
+    return done()
+  })
+
+  it('Test local ip async/await', async function() {
+    this.timeout(5000)
+    const result = await acgeoip.lookupLocal({ ip: '127.0.0.1', debug: false })    
+    expect(result).to.be.undefined
+  })
+
+  it('Shoud be tested with async/await', async function() {
+      this.timeout(5000)
+      const result = await acgeoip.lookupLocal({ ip, debug: false, refresh: true })    
+      let fields = ['iso2', 'city', 'region']
+      _.forEach(fields, key => {
+        let val = _.get(expectedValue, key)
+        expect(result).to.have.property(key, val)
+      })
+      expect(result).to.have.property('origin', 'db')
+      return 
+  })
+
+  it('Test again - should be from cache', async function() {
+    this.timeout(5000)
+    const result = await acgeoip.lookupLocal({ ip, debug: false })    
+    let fields = ['iso2', 'city', 'region']
+    _.forEach(fields, key => {
+      let val = _.get(expectedValue, key)
+      expect(result).to.have.property(key, val)
+    })
+    expect(result).to.have.property('origin', 'db')
+    expect(result).to.have.property('fromCache', true)
+    return 
+  })
+})
+