2.0.2

.gitignore

@@ -1,4 +1,4 @@
 node_modules/
 pages/
 public/
-
+coverage/

README.md

@@ -18,8 +18,15 @@ smart dns methods written in TypeScript
 [![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
 
 ## Usage
-we recommend the use of TypeScript
+we recommend the use of TypeScript for optimal intellisense
 ```javascript
+import * as dnsly from 'dnsly'
 
+let myDnsly = new dnsly.Dnsly('google') // uses Google DNS Servers e.g 8.8.8.8
+myDnsly.getRecord('example.com','AAAA') // returns promise
+    .then((record: dnsly.I_AAAA) => { // AAAA record for google.com, the I_AAAA will give you proper typings for the record return type
+        // do something 
+    })
 ```
+
 [![npm](https://push.rocks/assets/repo-header.svg)](https://push.rocks)

coverage/lcov.info

@@ -1,80 +0,0 @@
-TN:
-SF:/Users/philkunz/gitlab/pushrocks/dnsly/dist/index.js
-FN:3,(anonymous_1)
-FN:3,defineProperties
-FN:3,(anonymous_3)
-FN:5,_classCallCheck
-FN:13,(anonymous_5)
-FN:17,Dnsly
-FN:30,getRecord
-FN:37,(anonymous_8)
-FN:51,close
-FN:60,_setDnsProvider
-FNF:10
-FNH:10
-FNDA:1,(anonymous_1)
-FNDA:1,defineProperties
-FNDA:1,(anonymous_3)
-FNDA:2,_classCallCheck
-FNDA:1,(anonymous_5)
-FNDA:2,Dnsly
-FNDA:3,getRecord
-FNDA:3,(anonymous_8)
-FNDA:2,close
-FNDA:2,_setDnsProvider
-DA:3,3
-DA:5,2
-DA:7,1
-DA:8,1
-DA:13,1
-DA:17,1
-DA:18,2
-DA:20,2
-DA:21,2
-DA:28,1
-DA:31,3
-DA:32,3
-DA:38,3
-DA:39,0
-DA:41,3
-DA:43,3
-DA:52,2
-DA:61,2
-DA:62,2
-DA:63,2
-DA:65,0
-DA:70,1
-DA:73,1
-LF:23
-LH:21
-BRDA:3,1,0,3
-BRDA:3,1,1,3
-BRDA:3,2,0,3
-BRDA:3,2,1,0
-BRDA:3,3,0,1
-BRDA:3,3,1,0
-BRDA:3,4,0,0
-BRDA:3,4,1,1
-BRDA:5,5,0,0
-BRDA:5,5,1,2
-BRDA:38,6,0,0
-BRDA:38,6,1,3
-BRDA:61,7,0,2
-BRDA:61,7,1,0
-BRF:14
-BRH:8
-end_of_record
-TN:
-SF:/Users/philkunz/gitlab/pushrocks/dnsly/dist/dnsly.plugins.js
-FNF:0
-FNH:0
-DA:3,1
-DA:4,1
-DA:5,1
-DA:6,1
-DA:7,1
-LF:5
-LH:5
-BRF:0
-BRH:0
-end_of_record

dist/dnsly.plugins.d.ts

@@ -1,4 +1,5 @@
 import 'typings-global';
 import * as beautylog from 'beautylog';
-declare let dnsSocket: any;
-export { beautylog, dnsSocket };
+import * as dns from 'dns';
+import * as smartdelay from 'smartdelay';
+export { beautylog, dns, smartdelay };

dist/dnsly.plugins.js

@@ -2,6 +2,8 @@
 require("typings-global");
 const beautylog = require("beautylog");
 exports.beautylog = beautylog;
-let dnsSocket = require('dns-socket');
-exports.dnsSocket = dnsSocket;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG5zbHkucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2Ruc2x5LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDBCQUF1QjtBQUN2Qix1Q0FBc0M7QUFJbEMsOEJBQVM7QUFIYixJQUFJLFNBQVMsR0FBRyxPQUFPLENBQUMsWUFBWSxDQUFDLENBQUE7QUFJakMsOEJBQVMifQ==
+const dns = require("dns");
+exports.dns = dns;
+const smartdelay = require("smartdelay");
+exports.smartdelay = smartdelay;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG5zbHkucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2Ruc2x5LnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDBCQUF1QjtBQUN2Qix1Q0FBc0M7QUFLbEMsOEJBQVM7QUFKYiwyQkFBMEI7QUFLdEIsa0JBQUc7QUFKUCx5Q0FBd0M7QUFLcEMsZ0NBQVUifQ==

dist/index.d.ts

@@ -1,26 +1,42 @@
-/// <reference types="q" />
-import * as q from 'q';
 export declare type TDnsProvider = 'google';
 export declare type TDnsRecordType = 'A' | 'AAAA' | 'CNAME' | 'PTR' | 'MX' | 'NAPTR' | 'NS' | 'SOA' | 'SRV' | 'TXT';
+export interface IDnsRecord {
+    chunked?: string[];
+    name: string;
+    type: TDnsRecordType;
+    value: string;
+}
 /**
  * class dnsly offers methods for working with dns from a dns provider like Google DNS
  */
 export declare class Dnsly {
     dnsServerIp: string;
     dnsServerPort: number;
-    dnsSocketInstance: any;
     /**
      * constructor for class dnsly
      */
-    constructor(dnsProviderArg: TDnsProvider);
+    constructor(dnsProviderArg?: TDnsProvider);
     /**
      * gets a record
      */
-    getRecord(recordNameArg: string, recordTypeArg: TDnsRecordType): q.Promise<{}>;
+    getRecord(recordNameArg: string, recordTypeArg: TDnsRecordType): Promise<IDnsRecord[]>;
+    checkUntilAvailable(recordNameArg: string, recordTypeArg: TDnsRecordType, expectedValue: string): Promise<any>;
     /**
-     * close the dnsly instance
+     * get A Dns Record
      */
-    close(): void;
+    getRecordA(recordNameArg: string): Promise<IDnsRecord[]>;
+    /**
+     * get AAAA Record
+     */
+    getRecordAAAA(recordNameArg: string): Promise<IDnsRecord[]>;
+    /**
+     * gets a txt record
+     */
+    getRecordTxt(recordNameArg: string): Promise<IDnsRecord[]>;
+    /**
+     * get oridinary record
+     */
+    private getOrdinaryRecord(recordNameArg, recordTypeArg);
     /**
      * set the DNS provider
      */

dist/index.js

@@ -1,5 +1,13 @@
 "use strict";
-const q = require("q");
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const q = require("smartq");
 const plugins = require("./dnsly.plugins");
 /**
  * class dnsly offers methods for working with dns from a dns provider like Google DNS
@@ -8,33 +16,113 @@ class Dnsly {
     /**
      * constructor for class dnsly
      */
-    constructor(dnsProviderArg) {
+    constructor(dnsProviderArg = 'google') {
         this._setDnsProvider(dnsProviderArg);
-        this.dnsSocketInstance = plugins.dnsSocket();
     }
     /**
      * gets a record
      */
     getRecord(recordNameArg, recordTypeArg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (recordTypeArg) {
+                case 'TXT':
+                    return yield this.getRecordTxt(recordNameArg);
+                case 'A':
+                    return yield this.getRecordA(recordNameArg);
+                case 'AAAA':
+                    return yield this.getRecordAAAA(recordNameArg);
+            }
+        });
+    }
+    checkUntilAvailable(recordNameArg, recordTypeArg, expectedValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let cycleArg = 0;
+            let doCheck = () => __awaiter(this, void 0, void 0, function* () {
+                if (cycleArg < 30) {
+                    cycleArg++;
+                    try {
+                        let myRecordArray = yield this.getRecord(recordNameArg, recordTypeArg);
+                        let myRecord = myRecordArray[0].value;
+                        if (myRecord === expectedValue) {
+                            return true;
+                        }
+                        else {
+                            yield plugins.smartdelay.delayFor(500);
+                            return yield doCheck();
+                        }
+                    }
+                    catch (err) {
+                        yield plugins.smartdelay.delayFor(500);
+                        return yield doCheck();
+                    }
+                }
+                else {
+                    console.log('failed permanently...');
+                    return false;
+                }
+            });
+            return yield doCheck();
+        });
+    }
+    /**
+     * get A Dns Record
+     */
+    getRecordA(recordNameArg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.getOrdinaryRecord(recordNameArg, 'A');
+        });
+    }
+    /**
+     * get AAAA Record
+     */
+    getRecordAAAA(recordNameArg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.getOrdinaryRecord(recordNameArg, 'AAAA');
+        });
+    }
+    /**
+     * gets a txt record
+     */
+    getRecordTxt(recordNameArg) {
         let done = q.defer();
-        this.dnsSocketInstance.query({
-            questions: [{
-                    type: recordTypeArg,
-                    name: recordNameArg
-                }]
-        }, this.dnsServerPort, this.dnsServerIp, (err, res) => {
+        plugins.dns.resolveTxt(recordNameArg, (err, recordsArg) => {
             if (err) {
                 done.reject(err);
             }
-            done.resolve(res);
+            let responseArray = [];
+            for (let record of recordsArg) {
+                let recordAny = record; // fix wrong typings
+                responseArray.push({
+                    chunked: recordAny,
+                    name: recordNameArg,
+                    value: recordAny.join(' '),
+                    type: 'TXT'
+                });
+            }
+            done.resolve(responseArray);
         });
         return done.promise;
     }
     /**
-     * close the dnsly instance
+     * get oridinary record
      */
-    close() {
-        this.dnsSocketInstance.destroy();
+    getOrdinaryRecord(recordNameArg, recordTypeArg) {
+        let done = q.defer();
+        plugins.dns.resolve(recordNameArg, recordTypeArg, (err, recordsArg) => {
+            if (err) {
+                done.reject(err);
+            }
+            let responseArray = [];
+            for (let record of recordsArg) {
+                responseArray.push({
+                    name: recordNameArg,
+                    value: record,
+                    type: recordTypeArg
+                });
+            }
+            done.resolve(responseArray);
+        });
+        return done.promise;
     }
     /**
      * set the DNS provider
@@ -43,6 +131,7 @@ class Dnsly {
         if (dnsProvider === 'google') {
             this.dnsServerIp = '8.8.8.8';
             this.dnsServerPort = 53;
+            plugins.dns.setServers(['8.8.8.8', '8.8.4.4']);
         }
         else {
             throw new Error('unknown dns provider');
@@ -50,4 +139,4 @@ class Dnsly {
     }
 }
 exports.Dnsly = Dnsly;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsdUJBQXNCO0FBQ3RCLDJDQUEwQztBQWMxQzs7R0FFRztBQUNIO0lBSUk7O09BRUc7SUFDSCxZQUFZLGNBQTRCO1FBQ3BDLElBQUksQ0FBQyxlQUFlLENBQUMsY0FBYyxDQUFDLENBQUE7UUFDcEMsSUFBSSxDQUFDLGlCQUFpQixHQUFHLE9BQU8sQ0FBQyxTQUFTLEVBQUUsQ0FBQTtJQUNoRCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxTQUFTLENBQUMsYUFBcUIsRUFBRSxhQUE2QjtRQUMxRCxJQUFJLElBQUksR0FBRyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUE7UUFDcEIsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEtBQUssQ0FDeEI7WUFDSSxTQUFTLEVBQUUsQ0FBQztvQkFDUixJQUFJLEVBQUUsYUFBYTtvQkFDbkIsSUFBSSxFQUFFLGFBQWE7aUJBQ3RCLENBQUM7U0FDTCxFQUNELElBQUksQ0FBQyxhQUFhLEVBQ2xCLElBQUksQ0FBQyxXQUFXLEVBQ2hCLENBQUMsR0FBRyxFQUFFLEdBQUc7WUFDTCxFQUFFLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDO2dCQUNOLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUE7WUFDcEIsQ0FBQztZQUNELElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUE7UUFDckIsQ0FBQyxDQUFDLENBQUE7UUFDTixNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQTtJQUN2QixDQUFDO0lBRUQ7O09BRUc7SUFDSCxLQUFLO1FBQ0QsSUFBSSxDQUFDLGlCQUFpQixDQUFDLE9BQU8sRUFBRSxDQUFBO0lBQ3BDLENBQUM7SUFFRDs7T0FFRztJQUNLLGVBQWUsQ0FBQyxXQUF5QjtRQUM3QyxFQUFFLENBQUMsQ0FBQyxXQUFXLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQztZQUMzQixJQUFJLENBQUMsV0FBVyxHQUFHLFNBQVMsQ0FBQTtZQUM1QixJQUFJLENBQUMsYUFBYSxHQUFHLEVBQUUsQ0FBQTtRQUMzQixDQUFDO1FBQUMsSUFBSSxDQUFDLENBQUM7WUFDSixNQUFNLElBQUksS0FBSyxDQUFDLHNCQUFzQixDQUFDLENBQUE7UUFDM0MsQ0FBQztJQUNMLENBQUM7Q0FDSjtBQXJERCxzQkFxREMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQSw0QkFBMkI7QUFDM0IsMkNBQTBDO0FBcUIxQzs7R0FFRztBQUNIO0lBR0k7O09BRUc7SUFDSCxZQUFZLGlCQUErQixRQUFRO1FBQy9DLElBQUksQ0FBQyxlQUFlLENBQUMsY0FBYyxDQUFDLENBQUE7SUFDeEMsQ0FBQztJQUVEOztPQUVHO0lBQ0csU0FBUyxDQUFDLGFBQXFCLEVBQUUsYUFBNkI7O1lBQ2hFLE1BQU0sQ0FBQyxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUM7Z0JBQ3BCLEtBQUssS0FBSztvQkFDTixNQUFNLENBQUMsTUFBTSxJQUFJLENBQUMsWUFBWSxDQUFDLGFBQWEsQ0FBQyxDQUFBO2dCQUNqRCxLQUFLLEdBQUc7b0JBQ0osTUFBTSxDQUFDLE1BQU0sSUFBSSxDQUFDLFVBQVUsQ0FBQyxhQUFhLENBQUMsQ0FBQTtnQkFDL0MsS0FBSyxNQUFNO29CQUNQLE1BQU0sQ0FBQyxNQUFNLElBQUksQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFDLENBQUE7WUFDdEQsQ0FBQztRQUNMLENBQUM7S0FBQTtJQUVLLG1CQUFtQixDQUFDLGFBQXFCLEVBQUUsYUFBNkIsRUFBRSxhQUFxQjs7WUFDakcsSUFBSSxRQUFRLEdBQUcsQ0FBQyxDQUFBO1lBQ2hCLElBQUksT0FBTyxHQUFHO2dCQUNWLEVBQUUsQ0FBQyxDQUFDLFFBQVEsR0FBRyxFQUFFLENBQUMsQ0FBQyxDQUFDO29CQUNoQixRQUFRLEVBQUUsQ0FBQTtvQkFDVixJQUFJLENBQUM7d0JBQ0QsSUFBSSxhQUFhLEdBQUcsTUFBTSxJQUFJLENBQUMsU0FBUyxDQUFDLGFBQWEsRUFBRSxhQUFhLENBQUMsQ0FBQTt3QkFDdEUsSUFBSSxRQUFRLEdBQUcsYUFBYSxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQTt3QkFDckMsRUFBRSxDQUFDLENBQUMsUUFBUSxLQUFLLGFBQWEsQ0FBQyxDQUFDLENBQUM7NEJBQzdCLE1BQU0sQ0FBQyxJQUFJLENBQUE7d0JBQ2YsQ0FBQzt3QkFBQyxJQUFJLENBQUMsQ0FBQzs0QkFDSixNQUFNLE9BQU8sQ0FBQyxVQUFVLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFBOzRCQUN0QyxNQUFNLENBQUMsTUFBTSxPQUFPLEVBQUUsQ0FBQTt3QkFDMUIsQ0FBQztvQkFDTCxDQUFDO29CQUFDLEtBQUssQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7d0JBQ1gsTUFBTSxPQUFPLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQTt3QkFDdEMsTUFBTSxDQUFDLE1BQU0sT0FBTyxFQUFFLENBQUE7b0JBQzFCLENBQUM7Z0JBQ0wsQ0FBQztnQkFBQyxJQUFJLENBQUMsQ0FBQztvQkFDSixPQUFPLENBQUMsR0FBRyxDQUFDLHVCQUF1QixDQUFDLENBQUE7b0JBQ3BDLE1BQU0sQ0FBQyxLQUFLLENBQUE7Z0JBQ2hCLENBQUM7WUFDTCxDQUFDLENBQUEsQ0FBQTtZQUNELE1BQU0sQ0FBQyxNQUFNLE9BQU8sRUFBRSxDQUFBO1FBQzFCLENBQUM7S0FBQTtJQUVEOztPQUVHO0lBQ0csVUFBVSxDQUFDLGFBQXFCOztZQUNsQyxNQUFNLENBQUMsTUFBTSxJQUFJLENBQUMsaUJBQWlCLENBQUMsYUFBYSxFQUFFLEdBQUcsQ0FBQyxDQUFBO1FBQzNELENBQUM7S0FBQTtJQUVEOztPQUVHO0lBQ0csYUFBYSxDQUFDLGFBQXFCOztZQUNyQyxNQUFNLENBQUMsTUFBTSxJQUFJLENBQUMsaUJBQWlCLENBQUMsYUFBYSxFQUFFLE1BQU0sQ0FBQyxDQUFBO1FBQzlELENBQUM7S0FBQTtJQUVEOztPQUVHO0lBQ0gsWUFBWSxDQUFDLGFBQXFCO1FBQzlCLElBQUksSUFBSSxHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQWdCLENBQUE7UUFDbEMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsYUFBYSxFQUFFLENBQUMsR0FBRyxFQUFFLFVBQVU7WUFDbEQsRUFBRSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztnQkFDTixJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFBO1lBQ3BCLENBQUM7WUFDRCxJQUFJLGFBQWEsR0FBaUIsRUFBRSxDQUFBO1lBQ3BDLEdBQUcsQ0FBQyxDQUFDLElBQUksTUFBTSxJQUFJLFVBQVUsQ0FBQyxDQUFDLENBQUM7Z0JBQzVCLElBQUksU0FBUyxHQUFRLE1BQU0sQ0FBQSxDQUFDLG9CQUFvQjtnQkFDaEQsYUFBYSxDQUFDLElBQUksQ0FBQztvQkFDZixPQUFPLEVBQUUsU0FBUztvQkFDbEIsSUFBSSxFQUFFLGFBQWE7b0JBQ25CLEtBQUssRUFBRSxTQUFTLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQztvQkFDMUIsSUFBSSxFQUFFLEtBQUs7aUJBQ2QsQ0FBQyxDQUFBO1lBQ04sQ0FBQztZQUNELElBQUksQ0FBQyxPQUFPLENBQUMsYUFBYSxDQUFDLENBQUE7UUFDL0IsQ0FBQyxDQUFDLENBQUE7UUFDRixNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQTtJQUN2QixDQUFDO0lBRUQ7O09BRUc7SUFDSyxpQkFBaUIsQ0FBQyxhQUFxQixFQUFFLGFBQTZCO1FBQzFFLElBQUksSUFBSSxHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQWdCLENBQUE7UUFDbEMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsYUFBYSxFQUFFLGFBQWEsRUFBRSxDQUFDLEdBQUcsRUFBRSxVQUFVO1lBQzlELEVBQUUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7Z0JBQ04sSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQTtZQUNwQixDQUFDO1lBQ0QsSUFBSSxhQUFhLEdBQWlCLEVBQUUsQ0FBQTtZQUNwQyxHQUFHLENBQUMsQ0FBQyxJQUFJLE1BQU0sSUFBSSxVQUFVLENBQUMsQ0FBQyxDQUFDO2dCQUM1QixhQUFhLENBQUMsSUFBSSxDQUFDO29CQUNmLElBQUksRUFBRSxhQUFhO29CQUNuQixLQUFLLEVBQUUsTUFBTTtvQkFDYixJQUFJLEVBQUUsYUFBYTtpQkFDdEIsQ0FBQyxDQUFBO1lBQ04sQ0FBQztZQUNELElBQUksQ0FBQyxPQUFPLENBQUMsYUFBYSxDQUFDLENBQUE7UUFDL0IsQ0FBQyxDQUFDLENBQUE7UUFDRixNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQTtJQUN2QixDQUFDO0lBRUQ7O09BRUc7SUFDSyxlQUFlLENBQUMsV0FBeUI7UUFDN0MsRUFBRSxDQUFDLENBQUMsV0FBVyxLQUFLLFFBQVEsQ0FBQyxDQUFDLENBQUM7WUFDM0IsSUFBSSxDQUFDLFdBQVcsR0FBRyxTQUFTLENBQUE7WUFDNUIsSUFBSSxDQUFDLGFBQWEsR0FBRyxFQUFFLENBQUE7WUFDdkIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQyxTQUFTLEVBQUUsU0FBUyxDQUFDLENBQUMsQ0FBQTtRQUNsRCxDQUFDO1FBQUMsSUFBSSxDQUFDLENBQUM7WUFDSixNQUFNLElBQUksS0FBSyxDQUFDLHNCQUFzQixDQUFDLENBQUE7UUFDM0MsQ0FBQztJQUNMLENBQUM7Q0FDSjtBQTFIRCxzQkEwSEMifQ==

package.json

@@ -1,9 +1,9 @@
 {
   "name": "dnsly",
-  "version": "1.0.1",
+  "version": "2.0.2",
   "description": "smart dns methods written in TypeScript",
   "main": "dist/index.js",
-  "typings": "../dist/index.d.ts",
+  "typings": "dist/index.d.ts",
   "scripts": {
     "test": "(npmts)"
   },
@@ -23,15 +23,13 @@
   },
   "homepage": "https://gitlab.com/pushrocks/dnsly#README",
   "dependencies": {
-    "@types/q": "0.0.32",
     "beautylog": "^6.0.0",
-    "dns-socket": "^1.4.2",
-    "q": "^1.4.1",
+    "smartdelay": "^1.0.1",
+    "smartq": "^1.0.4",
     "typings-global": "^1.0.14"
   },
   "devDependencies": {
-    "@types/should": "^8.1.30",
-    "should": "^11.1.1",
+    "smartchai": "^1.0.1",
     "typings-test": "^1.0.3"
   }
 }

test/test.js

@@ -1,15 +1,37 @@
 "use strict";
 require("typings-test");
-const should = require("should");
+const smartchai_1 = require("smartchai");
 const dnsly = require("../dist/index");
 let testDnsly;
 describe('dnsly', function () {
     it('should create an instance of Dnsly', function () {
         testDnsly = new dnsly.Dnsly('google');
-        should(testDnsly).be.instanceOf(dnsly.Dnsly);
+        smartchai_1.expect(testDnsly).to.be.instanceOf(dnsly.Dnsly);
     });
-    it('should, get a dns record for a domain when called quickly', function (done) {
-        testDnsly.getRecord('google.com', 'A').then(res => {
+    it('should get an A DNS Record', function () {
+        return smartchai_1.expect(testDnsly.getRecordA('dnsly_a.bleu.de')).to.eventually.deep.equal([{
+                name: 'dnsly_a.bleu.de',
+                value: '127.0.0.1',
+                type: 'A'
+            }]);
+    });
+    it('should get an AAAA Record', function () {
+        return smartchai_1.expect(testDnsly.getRecordAAAA('dnsly_aaaa.bleu.de')).to.eventually.deep.equal([{
+                name: 'dnsly_aaaa.bleu.de',
+                value: '::1',
+                type: 'AAAA'
+            }]);
+    });
+    it('should get a txt record', function () {
+        return smartchai_1.expect(testDnsly.getRecordTxt('dnsly_txt.bleu.de')).to.eventually.deep.equal([{
+                chunked: ['sometext_txt'],
+                name: 'dnsly_txt.bleu.de',
+                value: 'sometext_txt',
+                type: 'TXT'
+            }]);
+    });
+    it('should, get a mx record for a domain', function (done) {
+        testDnsly.getRecord('google.com', 'MX').then(res => {
             console.log(res);
             done();
         }).catch(err => {
@@ -17,33 +39,12 @@ describe('dnsly', function () {
             done(err);
         });
     });
-    it('should, get a dns record for a domain when called with timeout', function (done) {
-        setTimeout(() => {
-            testDnsly.getRecord('google.com', 'A').then(res => {
-                console.log(res);
-                done();
-            }).catch(err => {
-                console.log(err);
-                done(err);
-            });
-        }, 1000);
+    it('should check until DNS is available', function () {
+        return smartchai_1.expect(testDnsly.checkUntilAvailable('dnsly_txt.bleu.de', 'TXT', 'sometext_txt')).to.eventually.be.true;
     });
-    it('should get a dns record for a domain when called with second instance and timeout', function (done) {
-        this.timeout(10000);
-        let testDnsly2 = new dnsly.Dnsly('google');
-        setTimeout(() => {
-            testDnsly2.getRecord('google.com', 'MX').then(res => {
-                console.log(res);
-                done();
-                testDnsly2.close();
-            }).catch(err => {
-                console.log(err);
-                done(err);
-            });
-        }, 5000);
-    });
-    it('should close the instance', function () {
-        testDnsly.close();
+    it('should check until DNS is available an return false if it fails', function () {
+        this.timeout(30000);
+        return smartchai_1.expect(testDnsly.checkUntilAvailable('dnsly_txt.bleu.de', 'TXT', 'sometext_txt2')).to.eventually.be.false;
     });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHdCQUFxQjtBQUNyQix5Q0FBa0M7QUFFbEMsdUNBQXNDO0FBRXRDLElBQUksU0FBc0IsQ0FBQTtBQUUxQixRQUFRLENBQUMsT0FBTyxFQUFFO0lBQ2QsRUFBRSxDQUFDLG9DQUFvQyxFQUFFO1FBQ3JDLFNBQVMsR0FBRyxJQUFJLEtBQUssQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLENBQUE7UUFDckMsa0JBQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUE7SUFDbkQsQ0FBQyxDQUFDLENBQUE7SUFFRixFQUFFLENBQUMsNEJBQTRCLEVBQUU7UUFDN0IsTUFBTSxDQUFDLGtCQUFNLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7Z0JBQzdFLElBQUksRUFBRSxpQkFBaUI7Z0JBQ3ZCLEtBQUssRUFBRyxXQUFXO2dCQUNuQixJQUFJLEVBQUUsR0FBRzthQUNaLENBQUMsQ0FBQyxDQUFBO0lBQ1AsQ0FBQyxDQUFDLENBQUE7SUFFRixFQUFFLENBQUMsMkJBQTJCLEVBQUU7UUFDNUIsTUFBTSxDQUFDLGtCQUFNLENBQUMsU0FBUyxDQUFDLGFBQWEsQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7Z0JBQ25GLElBQUksRUFBRSxvQkFBb0I7Z0JBQzFCLEtBQUssRUFBRyxLQUFLO2dCQUNiLElBQUksRUFBRSxNQUFNO2FBQ2YsQ0FBQyxDQUFDLENBQUE7SUFDUCxDQUFDLENBQUMsQ0FBQTtJQUVGLEVBQUUsQ0FBQyx5QkFBeUIsRUFBRTtRQUMxQixNQUFNLENBQUMsa0JBQU0sQ0FBQyxTQUFTLENBQUMsWUFBWSxDQUFDLG1CQUFtQixDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztnQkFDakYsT0FBTyxFQUFFLENBQUMsY0FBYyxDQUFDO2dCQUN6QixJQUFJLEVBQUUsbUJBQW1CO2dCQUN6QixLQUFLLEVBQUUsY0FBYztnQkFDckIsSUFBSSxFQUFFLEtBQUs7YUFDZCxDQUFDLENBQUMsQ0FBQTtJQUNQLENBQUMsQ0FBQyxDQUFBO0lBRUYsRUFBRSxDQUFDLHNDQUFzQyxFQUFFLFVBQVUsSUFBSTtRQUNyRCxTQUFTLENBQUMsU0FBUyxDQUFDLFlBQVksRUFBRSxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRztZQUM1QyxPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFBO1lBQ2hCLElBQUksRUFBRSxDQUFBO1FBQ1YsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLEdBQUc7WUFDUixPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFBO1lBQ2hCLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQTtRQUNiLENBQUMsQ0FBQyxDQUFBO0lBRU4sQ0FBQyxDQUFDLENBQUE7SUFFRixFQUFFLENBQUMscUNBQXFDLEVBQUU7UUFDdEMsTUFBTSxDQUFDLGtCQUFNLENBQUMsU0FBUyxDQUFDLG1CQUFtQixDQUFDLG1CQUFtQixFQUFDLEtBQUssRUFBQyxjQUFjLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQTtJQUNoSCxDQUFDLENBQUMsQ0FBQTtJQUVGLEVBQUUsQ0FBQyxpRUFBaUUsRUFBRTtRQUNsRSxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFBO1FBQ25CLE1BQU0sQ0FBQyxrQkFBTSxDQUFDLFNBQVMsQ0FBQyxtQkFBbUIsQ0FBQyxtQkFBbUIsRUFBQyxLQUFLLEVBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLEVBQUUsQ0FBQyxLQUFLLENBQUE7SUFDbEgsQ0FBQyxDQUFDLENBQUE7QUFDTixDQUFDLENBQUMsQ0FBQSJ9

test/test.ts

@@ -1,5 +1,5 @@
 import 'typings-test'
-import * as should from 'should'
+import { expect } from 'smartchai'
 
 import * as dnsly from '../dist/index'
 
@@ -8,11 +8,36 @@ let testDnsly: dnsly.Dnsly
 describe('dnsly', function () {
     it('should create an instance of Dnsly', function () {
         testDnsly = new dnsly.Dnsly('google')
-        should(testDnsly).be.instanceOf(dnsly.Dnsly)
+        expect(testDnsly).to.be.instanceOf(dnsly.Dnsly)
     })
 
-    it('should, get a dns record for a domain', function (done) {
-        testDnsly.getRecord('google.com', 'A').then(res => {
+    it('should get an A DNS Record', function () {
+        return expect(testDnsly.getRecordA('dnsly_a.bleu.de')).to.eventually.deep.equal([{
+            name: 'dnsly_a.bleu.de',
+            value:  '127.0.0.1',
+            type: 'A'
+        }])
+    })
+
+    it('should get an AAAA Record', function () {
+        return expect(testDnsly.getRecordAAAA('dnsly_aaaa.bleu.de')).to.eventually.deep.equal([{
+            name: 'dnsly_aaaa.bleu.de',
+            value:  '::1',
+            type: 'AAAA'
+        }])
+    })
+
+    it('should get a txt record', function() {
+        return expect(testDnsly.getRecordTxt('dnsly_txt.bleu.de')).to.eventually.deep.equal([{
+            chunked: ['sometext_txt'],
+            name: 'dnsly_txt.bleu.de',
+            value: 'sometext_txt',
+            type: 'TXT'
+        }])
+    })
+
+    it('should, get a mx record for a domain', function (done) {
+        testDnsly.getRecord('google.com', 'MX').then(res => {
             console.log(res)
             done()
         }).catch(err => {
@@ -22,7 +47,12 @@ describe('dnsly', function () {
 
     })
 
-    it('should close the instance', function () {
-        testDnsly.close()
+    it('should check until DNS is available', function() {
+        return expect(testDnsly.checkUntilAvailable('dnsly_txt.bleu.de','TXT','sometext_txt')).to.eventually.be.true
+    })
+
+    it('should check until DNS is available an return false if it fails', function() {
+        this.timeout(30000)
+        return expect(testDnsly.checkUntilAvailable('dnsly_txt.bleu.de','TXT','sometext_txt2')).to.eventually.be.false
     })
 })

ts/dnsly.plugins.ts

@@ -1,8 +1,10 @@
 import 'typings-global'
 import * as beautylog from 'beautylog'
-let dnsSocket = require('dns-socket')
+import * as dns from 'dns'
+import * as smartdelay from 'smartdelay'
 
 export {
     beautylog,
-    dnsSocket
+    dns,
+    smartdelay
 }

ts/index.ts

@@ -1,4 +1,4 @@
-import * as q from 'q'
+import * as q from 'smartq'
 import * as plugins from './dnsly.plugins'
 
 export type TDnsProvider = 'google'
@@ -13,49 +13,124 @@ export type TDnsRecordType = 'A'
     | 'SRV'
     | 'TXT'
 
+export interface IDnsRecord {
+    chunked?: string[]
+    name: string
+    type: TDnsRecordType
+    value: string
+}
+
 /**
  * class dnsly offers methods for working with dns from a dns provider like Google DNS
  */
 export class Dnsly {
     dnsServerIp: string
     dnsServerPort: number
-    dnsSocketInstance
     /**
      * constructor for class dnsly
      */
-    constructor(dnsProviderArg: TDnsProvider) {
+    constructor(dnsProviderArg: TDnsProvider = 'google') {
         this._setDnsProvider(dnsProviderArg)
-        this.dnsSocketInstance = plugins.dnsSocket()
     }
 
     /**
      * gets a record
      */
-    getRecord(recordNameArg: string, recordTypeArg: TDnsRecordType) {
-        let done = q.defer()
-        this.dnsSocketInstance.query(
-            {
-                questions: [{
-                    type: recordTypeArg,
-                    name: recordNameArg
-                }]
-            },
-            this.dnsServerPort,
-            this.dnsServerIp,
-            (err, res) => {
-                if (err) {
-                    done.reject(err)
+    async getRecord(recordNameArg: string, recordTypeArg: TDnsRecordType): Promise<IDnsRecord[]> {
+        switch (recordTypeArg) {
+            case 'TXT':
+                return await this.getRecordTxt(recordNameArg)
+            case 'A':
+                return await this.getRecordA(recordNameArg)
+            case 'AAAA':
+                return await this.getRecordAAAA(recordNameArg)
+        }
+    }
+
+    async checkUntilAvailable(recordNameArg: string, recordTypeArg: TDnsRecordType, expectedValue: string) {
+        let cycleArg = 0
+        let doCheck = async () => {
+            if (cycleArg < 30) {
+                cycleArg++
+                try {
+                    let myRecordArray = await this.getRecord(recordNameArg, recordTypeArg)
+                    let myRecord = myRecordArray[0].value
+                    if (myRecord === expectedValue) {
+                        return true
+                    } else {
+                        await plugins.smartdelay.delayFor(500)
+                        return await doCheck()
+                    }
+                } catch (err) {
+                    await plugins.smartdelay.delayFor(500)
+                    return await doCheck()
                 }
-                done.resolve(res)
-            })
+            } else {
+                console.log('failed permanently...')
+                return false
+            }
+        }
+        return await doCheck()
+    }
+
+    /**
+     * get A Dns Record
+     */
+    async getRecordA(recordNameArg: string): Promise<IDnsRecord[]> {
+        return await this.getOrdinaryRecord(recordNameArg, 'A')
+    }
+
+    /**
+     * get AAAA Record
+     */
+    async getRecordAAAA(recordNameArg: string) {
+        return await this.getOrdinaryRecord(recordNameArg, 'AAAA')
+    }
+
+    /**
+     * gets a txt record
+     */
+    getRecordTxt(recordNameArg: string): Promise<IDnsRecord[]> {
+        let done = q.defer<IDnsRecord[]>()
+        plugins.dns.resolveTxt(recordNameArg, (err, recordsArg) => {
+            if (err) {
+                done.reject(err)
+            }
+            let responseArray: IDnsRecord[] = []
+            for (let record of recordsArg) {
+                let recordAny: any = record // fix wrong typings
+                responseArray.push({
+                    chunked: recordAny,
+                    name: recordNameArg,
+                    value: recordAny.join(' '),
+                    type: 'TXT'
+                })
+            }
+            done.resolve(responseArray)
+        })
         return done.promise
     }
 
     /**
-     * close the dnsly instance
+     * get oridinary record
      */
-    close() {
-        this.dnsSocketInstance.destroy()
+    private getOrdinaryRecord(recordNameArg: string, recordTypeArg: TDnsRecordType): Promise<IDnsRecord[]> {
+        let done = q.defer<IDnsRecord[]>()
+        plugins.dns.resolve(recordNameArg, recordTypeArg, (err, recordsArg) => {
+            if (err) {
+                done.reject(err)
+            }
+            let responseArray: IDnsRecord[] = []
+            for (let record of recordsArg) {
+                responseArray.push({
+                    name: recordNameArg,
+                    value: record,
+                    type: recordTypeArg
+                })
+            }
+            done.resolve(responseArray)
+        })
+        return done.promise
     }
 
     /**
@@ -65,8 +140,9 @@ export class Dnsly {
         if (dnsProvider === 'google') {
             this.dnsServerIp = '8.8.8.8'
             this.dnsServerPort = 53
+            plugins.dns.setServers(['8.8.8.8', '8.8.4.4'])
         } else {
             throw new Error('unknown dns provider')
         }
     }
-}
+}