fakefilter 0.1.97 → 0.1.100

package/README.md

@@ -33,11 +33,13 @@ This format supports firstseen,lastseen,randomSubdomain properties
 [Txt](txt/data.txt)
 
 ## Javascript
-We have implemented npm/javascript interface for Javascript Developers
+We have implemented npm/javascript interface for Javascript Developers as demonstration
 
 `npm i --save fakefilter`
 
-Demo:
+You have to make sure that this npm package is always up2date in order this static implementation to work as designed.
+
+Offline Lookup:
 ```
 const { isFakeDomain, isFakeEmail } = require('fakefilter')
 
@@ -45,6 +47,20 @@ console.log(isFakeDomain('domain.com'))
 console.log(isFakeEmail('user@domain.com'))
 ```
 
+
+Online Lookup:
+
+this version does not throw at all. You either get null (which indicates any error) or false or the object as reply
+```
+## also see examples/online.js
+const { isFakeDomainOnline, isFakeEmailOnline } = require('fakefilter')
+
+console.log(await isFakeDomainOnline('domain.com'))
+console.log(await isFakeEmailOnline('user@domain.com'))
+
+```
+
+
 Test:
 ```
 node index.js

package/examples/online.js

@@ -0,0 +1,16 @@
+const { isFakeDomainOnline, isFakeEmailOnline } = require('./../index')
+
+async function start() {
+    try {
+        // not disposable answer
+        console.log(await isFakeDomainOnline('domain.com'))
+        console.log(await isFakeEmailOnline('user@domain.com'))
+        // disposable answer
+        console.log(await isFakeDomainOnline('grr.la'))
+        console.log(await isFakeEmailOnline('user@grr.la'))
+    } catch (err) {
+        console.log(err)
+    }
+}
+
+start()

package/index.js

@@ -1,62 +1,185 @@
-
 /*
+
     Basic Javascript Interface to lookup by Email or Domain
+
+    Important: you need to auto update npm package daily to make continious feed
+
 */
 const assert = require('assert');
 const static_json = require('./json/data.json')
+const https = require('https')
 
 function hostnameFromEmailAddress(email) {
-    if (email && typeof email==='string' && email.search(/@/)>0)
+    if (email && typeof email === 'string' && email.search(/@/) > 0)
         return email.split(/@/)[1]
     return null
 }
 
-function isFakeDomain(domain,json=false) {
-    if (!json) json=static_json
-    for(let dom of Object.keys(json.domains)) {
+function isFakeDomain(domain, json = false) {
+    if (!json) json = static_json
+    for (let dom of Object.keys(json.domains)) {
         // exact match
-        if (dom===domain.toLowerCase().trim()) return dom
+        if (dom === domain.toLowerCase().trim()) return dom
         // subdomain match
-        if (domain.search(new RegExp(`.+\\.${dom}`))===0) return dom
+        if (domain.search(new RegExp(`.+\\.${dom}`)) === 0) return dom
     }
     return false
 }
 
-function isFakeEmail(email,json=false) {
-    return isFakeDomain(hostnameFromEmailAddress(email),json)
+function fetch(url, timeout = 5000,json=true) {
+    return new Promise(async function (resolve, reject) {
+        try {
+            let request = https.get(url, (res) => {
+                if (res.statusCode !== 200) {
+                    res.resume()
+                    return reject('STATUSCODE')
+                }
+                let data = ''
+                res.on('data', (chunk) => { data += chunk })
+                res.on('close', () => {
+                    if (json) {
+                        try {
+                            return resolve(JSON.parse(data))
+                        }catch(err) {
+                            return resolve(false)
+                        }
+                    }
+                    return resolve(data)
+                })
+            })
+            request.setTimeout(timeout, () => {
+                request.destroy()
+                return reject('TIMEOUT')
+            })
+            request.end()
+
+            request.on('error', (err) => {
+                return reject(err)
+            })
+        } catch (err3) {
+            // errors like ERR_INVALID_PROTOCOL is thrown here
+            reject(err3)
+        }
+    })
 }
 
-// basic tests
-if (require.main==module) {
+function isFakeEmail(email, json = false) {
+    return isFakeDomain(hostnameFromEmailAddress(email), json)
+}
+
+function isFakeEmailOnline(email, timeout=5000) {
+    return isFakeDomainOnline(hostnameFromEmailAddress(email), timeout)
+}
+
+
+function isFakeDomainOnline(domain,timeout=5000) {
+    // we intentionally do not reject because we do not want to hold
+    // the process too long, null indicates error
+    return new Promise(async function (resolve, reject) {
+        try {
+            let answer = await fetch(`https://fakefilter.net/api/is/fakedomain/${domain}`,timeout,true)
+            if (answer && answer.hasOwnProperty('retcode') && answer.retcode===200)
+                return resolve(answer)
+        }catch(err) {
+            // error returns null
+            return resolve(null)
+        }
+    })
+}
+
+async function runTests() {
+    // fetch tests
+
+    // not existing domain
+    try {
+        await fetch(`https://nonexisting${Date.now()}.com`)
+        assert.equal(false, true) // we should never reach this position
+    } catch (err) {
+        assert.equal(err.code, 'ENOTFOUND')
+    }
+
+    // not existing url on existing domain
+    try {
+        await fetch(`https://fakefilter.net/notexisting`)
+        assert.equal(false, true) // we should never reach this position
+    } catch (err) {
+        assert.equal(err, 'STATUSCODE')
+    }
+
+    // invalid protocoll
+    try {
+        await fetch(`htps://fakefilter.net/notexisting`)
+        assert.equal(false, true) // we should never reach this position
+    } catch (err) {
+        assert.equal(err.code, 'ERR_INVALID_PROTOCOL')
+    }
+
+    // invalid url
+    try {
+        await fetch(`://fakefilter.net/notexisting`)
+        assert.equal(false, true) // we should never reach this position
+    } catch (err) {
+        assert.equal(err.code, 'ERR_INVALID_URL')
+    }
+
+
+    // 404
+    try {
+        await fetch(`https://fakefilter.net/api/is/fakedomain/`)
+        assert.equal(false, true) // we should never reach this position
+    } catch (err) {
+        assert.equal(err, 'STATUSCODE')
+    }
+
+    // non FakeDomain
+    assert.equal((await fetch(`https://fakefilter.net/api/is/fakedomain/fakefilter.net`)).retcode,200)
+    // FakeDomain
+    assert.equal((await fetch(`https://fakefilter.net/api/is/fakedomain/fakefilte r.net`)).retcode,-50)    
+
+
     let json = static_json
     console.log(`Running tests`)
     let all_domains = Object.keys(json.domains)
+
     // all domains we know must be detected as FakeDomain
-    for(let domain of all_domains)
-    {
+    for (let domain of all_domains) {
+        // if (domain!=='www.barryogorman.com') continue
         // console.log((domain),isFakeDomain(domain)===domain.toLowerCase())
         // exact match
-        
-        assert.notEqual(isFakeDomain(domain),false)
+        // console.log(`>> ${domain}`)
+
+        assert.notEqual(isFakeDomain(domain), false)
         // subdomain match for example any@sub.test.com should match if test.com is part of the filter
-        assert.notEqual(isFakeDomain(`sub.${domain}`),false)
+        assert.notEqual(isFakeDomain(`sub.${domain}`), false)
 
-        assert.notEqual(isFakeDomain(`sub.sub.${domain}`),false)
-        assert.notEqual(isFakeDomain(`another.sub.sub.${domain}`),false)
+        assert.notEqual(isFakeDomain(`sub.sub.${domain}`), false)
+        assert.notEqual(isFakeDomain(`another.sub.sub.${domain}`), false)
         // sub$hostname should not be detected as fakedomain - if we have test.com in the filter, subtest.com should not be detected as fake
-        if (domain.search(/^[^.]+\.[^.]+$/)==0) 
-            {
-                assert.equal(isFakeEmail(`any@sub${domain}`),false)
-                assert.equal(isFakeDomain(`sub${domain}`),false)
-            }
-        assert.notEqual(isFakeEmail(`any@${domain}`),false)
-        assert.notEqual(isFakeEmail(`any@sub.${domain}`),false)
+        if (domain.search(/^[^.]+\.[^.]+$/) == 0) {
+            assert.equal(isFakeEmail(`any@sub${domain}`), false)
+            assert.equal(isFakeDomain(`sub${domain}`), false)
+        }
+        assert.notEqual(isFakeEmail(`any@${domain}`), false)
+        assert.notEqual(isFakeEmail(`any@sub.${domain}`), false)
+
+        // RESTFul API query
+        assert.equal((await isFakeDomainOnline(domain)).isFakeDomain,domain)
+        assert.equal((await isFakeEmailOnline(`any@${domain}`)).isFakeDomain, domain)
+        assert.equal((await isFakeEmailOnline(`any@sub${domain}`)).isFakeDomain, false)
     }
     console.log(`OK`)
+    process.exit(0)
 }
 
+// basic tests
+if (require.main == module) runTests()
 
 module.exports = {
+    // offline version
     isFakeDomain,
-    isFakeEmail
+    isFakeEmail,
+
+    // online version
+    isFakeDomainOnline,
+    isFakeEmailOnline
 }