update to better API

ts/dnsly.plugins.ts

@@ -1,8 +1,10 @@
 import 'typings-global'
 import * as beautylog from 'beautylog'
 import * as dns from 'dns'
+import * as smartdelay from 'smartdelay'
 
 export {
     beautylog,
-    dns
+    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,6 +13,13 @@ 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
  */
@@ -22,20 +29,106 @@ export class Dnsly {
     /**
      * constructor for class dnsly
      */
-    constructor(dnsProviderArg: TDnsProvider) {
+    constructor(dnsProviderArg: TDnsProvider = 'google') {
         this._setDnsProvider(dnsProviderArg)
     }
 
     /**
      * gets a record
      */
-    getRecord(recordNameArg: string, recordTypeArg: TDnsRecordType) {
-        let done = q.defer()
-        plugins.dns.resolve(recordNameArg,recordTypeArg, (err, addresses) => {
+    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()
+                }
+            } 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)
             }
-            done.resolve(addresses)
+            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
+    }
+
+    /**
+     * get oridinary record
+     */
+    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
     }
@@ -47,9 +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'])
+            plugins.dns.setServers(['8.8.8.8', '8.8.4.4'])
         } else {
             throw new Error('unknown dns provider')
         }
     }
-}
+}