@nictool/dns-resource-record 1.1.7 → 1.2.0

package/rr/soa.js

@@ -1,13 +1,12 @@
-
 import RR from '../rr.js'
 
 export default class SOA extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setMinimum (val) {
+  setMinimum(val) {
     // minimum (used for negative caching, since RFC 2308)
     // RFC 1912 sugggests 1-5 days
     // RIPE recommends 3600 (1 hour)
@@ -16,7 +15,7 @@ export default class SOA extends RR {
     this.set('minimum', val)
   }
 
-  setMname (val) {
+  setMname(val) {
     // MNAME (primary NS)
     this.isValidHostname('SOA', 'MNAME', val)
     this.isFullyQualified('SOA', 'MNAME', val)
@@ -25,23 +24,24 @@ export default class SOA extends RR {
     this.set('mname', val.toLowerCase())
   }
 
-  setRname (val) {
+  setRname(val) {
     // RNAME (email of admin)  (escape . with \)
     this.isValidHostname('SOA', 'RNAME', val)
     this.isFullyQualified('SOA', 'RNAME', val)
-    if (/@/.test(val)) throw new Error(`SOA rname replaces @ with a . (dot), ${this.citeRFC()}`)
+    if (/@/.test(val))
+      throw new Error(`SOA rname replaces @ with a . (dot), ${this.citeRFC()}`)
 
     // RFC 4034: letters in the DNS names are lower cased
     this.set('rname', val.toLowerCase())
   }
 
-  setSerial (val) {
+  setSerial(val) {
     this.is32bitInt('SOA', 'serial', val)
 
     this.set('serial', val)
   }
 
-  setRefresh (val) {
+  setRefresh(val) {
     // refresh (seconds after which to check with master for update)
     // RFC 1912 suggests 20 min to 12 hours
     // RIPE recommends 86400 (24 hours)
@@ -50,7 +50,7 @@ export default class SOA extends RR {
     this.set('refresh', val)
   }
 
-  setRetry (val) {
+  setRetry(val) {
     // seconds after which to retry serial # update
     // RIPE recommends 7200 seconds (2 hours)
 
@@ -59,7 +59,7 @@ export default class SOA extends RR {
     this.set('retry', val)
   }
 
-  setExpire (val) {
+  setExpire(val) {
     // seconds after which secondary should drop zone if no master response
     // RFC 1912 suggests 2-4 weeks
     // RIPE suggests 3600000 (1,000 hours, 6 weeks)
@@ -68,73 +68,88 @@ export default class SOA extends RR {
     this.set('expire', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Start Of Authority'
   }
 
-  getRdataFields (arg) {
-    return [ 'mname', 'rname', 'serial', 'refresh', 'retry', 'expire', 'minimum' ]
+  getRdataFields(arg) {
+    return ['mname', 'rname', 'serial', 'refresh', 'retry', 'expire', 'minimum']
   }
 
-  getRFCs () {
-    return [ 1035, 2308 ]
+  getRFCs() {
+    return [1035, 2308]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 6
   }
 
   /******  IMPORTERS   *******/
-  fromBind (opts) {
+  fromBind(opts) {
     // example.com TTL IN  SOA mname rname serial refresh retry expire minimum
-    const [ owner, ttl, c, type, mname, rname, serial, refresh, retry, expire, minimum ] = opts.bindline.split(/[\s+]/)
+    const [
+      owner,
+      ttl,
+      c,
+      type,
+      mname,
+      rname,
+      serial,
+      refresh,
+      retry,
+      expire,
+      minimum,
+    ] = opts.bindline.split(/[\s+]/)
 
     return new SOA({
       owner,
-      ttl    : parseInt(ttl) || parseInt(minimum),
-      class  : c,
+      ttl: parseInt(ttl) || parseInt(minimum),
+      class: c,
       type,
       mname,
       rname,
-      serial : parseInt(serial , 10),
+      serial: parseInt(serial, 10),
       refresh: parseInt(refresh, 10),
-      retry  : parseInt(retry  , 10),
-      expire : parseInt(expire , 10),
+      retry: parseInt(retry, 10),
+      expire: parseInt(expire, 10),
       minimum: parseInt(minimum, 10),
     })
   }
 
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // Zfqdn:mname:rname:ser:ref:ret:exp:min:ttl:time:lo
-    const [ fqdn, mname, rname, ser, ref, ret, exp, min, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    const [fqdn, mname, rname, ser, ref, ret, exp, min, ttl, ts, loc] =
+      opts.tinyline.substring(1).split(':')
 
     return new SOA({
-      owner    : this.fullyQualify(fqdn),
-      ttl      : parseInt(ttl, 10),
-      type     : 'SOA',
-      mname    : this.fullyQualify(mname),
-      rname    : this.fullyQualify(rname),
-      serial   : parseInt(ser || opts.default?.serial, 10),
-      refresh  : parseInt(ref, 10) || 16384,
-      retry    : parseInt(ret, 10) || 2048,
-      expire   : parseInt(exp, 10) || 1048576,
-      minimum  : parseInt(min, 10) || 2560,
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'SOA',
+      mname: this.fullyQualify(mname),
+      rname: this.fullyQualify(rname),
+      serial: parseInt(ser || opts.default?.serial, 10),
+      refresh: parseInt(ref, 10) || 16384,
+      retry: parseInt(ret, 10) || 2048,
+      expire: parseInt(exp, 10) || 1048576,
+      minimum: parseInt(min, 10) || 2560,
       timestamp: parseInt(ts) || '',
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
   /******  EXPORTERS   *******/
-  toBind (zone_opts) {
-    const numFields = [ 'serial', 'refresh', 'retry', 'expire', 'minimum' ]
-    return `${this.getFQDN('owner', zone_opts)}\t${this.get('ttl')}\t${this.get('class')}\tSOA\t${this.getFQDN('mname', zone_opts)}\t${this.getFQDN('rname', zone_opts)}${numFields.map(f => '\t' + this.get(f) ).join('')}\n`
+  toBind(zone_opts) {
+    const numFields = ['serial', 'refresh', 'retry', 'expire', 'minimum']
+    return `${this.getFQDN('owner', zone_opts)}\t${this.get('ttl')}\t${this.get('class')}\tSOA\t${this.getFQDN('mname', zone_opts)}\t${this.getFQDN('rname', zone_opts)}${numFields.map((f) => '\t' + this.get(f)).join('')}\n`
   }
 
-  toMaraDNS () {
-    return `${this.get('owner')}\t SOA\t${this.getRdataFields().map(f => this.getQuoted(f)).join('\t')} ~\n`
+  toMaraDNS() {
+    return `${this.get('owner')}\t SOA\t${this.getRdataFields()
+      .map((f) => this.getQuoted(f))
+      .join('\t')} ~\n`
   }
 
-  toTinydns () {
+  toTinydns() {
     return `Z${this.getTinyFQDN('owner')}:${this.getTinyFQDN('mname')}:${this.getTinyFQDN('rname')}:${this.getEmpty('serial')}:${this.getEmpty('refresh')}:${this.getEmpty('retry')}:${this.getEmpty('expire')}:${this.getEmpty('minimum')}:${this.getTinydnsPostamble()}\n`
   }
 }

package/rr/spf.js

@@ -5,50 +5,53 @@ import TXT from './txt.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class SPF extends TXT {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setData (val) {
+  setData(val) {
     this.set('data', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Sender Policy Framework'
   }
 
-  getRdataFields (arg) {
-    return [ 'data' ]
+  getRdataFields(arg) {
+    return ['data']
   }
 
-  getRFCs () {
-    return [ 4408, 7208 ]
+  getRFCs() {
+    return [4408, 7208]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 99
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // SPF via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
     if (n != 99) throw new Error('SPF fromTinydns, invalid n')
 
     return new SPF({
-      type     : 'SPF',
-      owner    : this.fullyQualify(fqdn),
-      data     : TINYDNS.octalToChar(rdata),
-      ttl      : parseInt(ttl, 10),
+      type: 'SPF',
+      owner: this.fullyQualify(fqdn),
+      data: TINYDNS.octalToChar(rdata),
+      ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
   /******  EXPORTERS   *******/
-  toTinydns () {
-    const rdata = TINYDNS.escapeOctal(new RegExp(/[\r\n\t:\\/]/, 'g'), this.get('data'))
+  toTinydns() {
+    const rdata = TINYDNS.escapeOctal(
+      new RegExp(/[\r\n\t:\\/]/, 'g'),
+      this.get('data'),
+    )
     return this.getTinydnsGeneric(rdata)
   }
 }

package/rr/srv.js

@@ -1,34 +1,33 @@
-
 import net from 'net'
 
 import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class SRV extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setPriority (val) {
+  setPriority(val) {
     this.is16bitInt('SRV', 'priority', val)
 
     this.set('priority', val)
   }
 
-  setPort (val) {
+  setPort(val) {
     this.is16bitInt('SRV', 'port', val)
 
     this.set('port', val)
   }
 
-  setWeight (val) {
+  setWeight(val) {
     this.is16bitInt('SRV', 'weight', val)
 
     this.set('weight', val)
   }
 
-  setTarget (val) {
+  setTarget(val) {
     if (!val) throw new Error(`SRV: target is required, ${this.citeRFC()}`)
 
     if (net.isIPv4(val) || net.isIPv6(val))
@@ -41,77 +40,78 @@ export default class SRV extends RR {
     this.set('target', val.toLowerCase())
   }
 
-  getDescription () {
+  getDescription() {
     return 'Service'
   }
 
-  getRdataFields (arg) {
-    return [ 'priority', 'weight', 'port', 'target' ]
+  getRdataFields(arg) {
+    return ['priority', 'weight', 'port', 'target']
   }
 
-  getRFCs () {
-    return [ 2782 ]
+  getRFCs() {
+    return [2782]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 33
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     const str = opts.tinyline
     let fqdn, addr, port, pri, weight, ttl, ts, loc, n, rdata
 
     if (str[0] === 'S') {
       // patched tinydns with S records
-      [ fqdn, addr, port, pri, weight, ttl, ts, loc ] = str.substring(1).split(':')
-    }
-    else {
+      ;[fqdn, addr, port, pri, weight, ttl, ts, loc] = str
+        .substring(1)
+        .split(':')
+    } else {
       // tinydns generic record format
-      [ fqdn, n, rdata, ttl, ts, loc ] = str.substring(1).split(':')
+      ;[fqdn, n, rdata, ttl, ts, loc] = str.substring(1).split(':')
       if (n != 33) throw new Error('SRV fromTinydns: invalid n')
 
-      pri    = TINYDNS.octalToUInt16(rdata.substring(0, 8))
+      pri = TINYDNS.octalToUInt16(rdata.substring(0, 8))
       weight = TINYDNS.octalToUInt16(rdata.substring(8, 16))
-      port   = TINYDNS.octalToUInt16(rdata.substring(16, 24))
-      addr   = (TINYDNS.unpackDomainName(rdata.substring(24)))[0]
+      port = TINYDNS.octalToUInt16(rdata.substring(16, 24))
+      addr = TINYDNS.unpackDomainName(rdata.substring(24))[0]
     }
 
     return new SRV({
-      owner    : this.fullyQualify(fqdn),
-      ttl      : parseInt(ttl,    10),
-      type     : 'SRV',
-      priority : parseInt(pri,    10),
-      weight   : parseInt(weight, 10),
-      port     : parseInt(port,   10),
-      target   : this.fullyQualify(addr),
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'SRV',
+      priority: parseInt(pri, 10),
+      weight: parseInt(weight, 10),
+      port: parseInt(port, 10),
+      target: this.fullyQualify(addr),
       timestamp: ts,
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  SRV Priority Weight Port Target
-    const [ owner, ttl, c, type, pri, weight, port, target ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, pri, weight, port, target] =
+      opts.bindline.split(/\s+/)
     return new SRV({
-      owner   : owner,
-      ttl     : parseInt(ttl,    10),
-      class   : c,
-      type    : type,
-      priority: parseInt(pri,    10),
-      weight  : parseInt(weight, 10),
-      port    : parseInt(port,   10),
-      target  : target,
+      owner: owner,
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
+      priority: parseInt(pri, 10),
+      weight: parseInt(weight, 10),
+      port: parseInt(port, 10),
+      target: target,
     })
   }
 
   /******  EXPORTERS   *******/
 
-  toTinydns () {
-
+  toTinydns() {
     let rdata = ''
 
-    for (const e of [ 'priority', 'weight', 'port' ]) {
+    for (const e of ['priority', 'weight', 'port']) {
       rdata += TINYDNS.UInt16toOctal(this.get(e))
     }
 

package/rr/sshfp.js

@@ -1,86 +1,85 @@
-
 import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class SSHFP extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setAlgorithm (val) {
+  setAlgorithm(val) {
     // 0: reserved  1: RSA  2: DSA  3: ECDSA  4: Ed25519  6: Ed448
     this.is8bitInt('SSHFP', 'algorithm', val)
 
     this.set('algorithm', val)
   }
 
-  setFptype (val) {
+  setFptype(val) {
     // 0: reserved, 1: SHA-1, 2: SHA-256
     this.is8bitInt('SSHFP', 'type', val)
 
     this.set('fptype', val)
   }
 
-  setFingerprint (val) {
+  setFingerprint(val) {
     this.set('fingerprint', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Secure Shell Key Fingerprints'
   }
 
-  getRdataFields () {
-    return [ 'algorithm', 'fptype', 'fingerprint' ]
+  getRdataFields() {
+    return ['algorithm', 'fptype', 'fingerprint']
   }
 
-  getRFCs () {
-    return [ 4255, 7479, 8709 ]
+  getRFCs() {
+    return [4255, 7479, 8709]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 44
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // SSHFP via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
     if (n != 44) throw new Error('SSHFP fromTinydns, invalid n')
 
     return new SSHFP({
-      owner      : this.fullyQualify(fqdn),
-      ttl        : parseInt(ttl, 10),
-      type       : 'SSHFP',
-      algorithm  : TINYDNS.octalToUInt8(rdata.substring(0, 4)),
-      fptype     : TINYDNS.octalToUInt8(rdata.substring(4, 8)),
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'SSHFP',
+      algorithm: TINYDNS.octalToUInt8(rdata.substring(0, 4)),
+      fptype: TINYDNS.octalToUInt8(rdata.substring(4, 8)),
       fingerprint: TINYDNS.octalToHex(rdata.substring(8)),
-      timestamp  : ts,
-      location   : loc !== '' && loc !== '\n' ? loc : '',
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  SSHFP  algo fptype fp
-    const [ owner, ttl, c, type, algo, fptype, fp ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, algo, fptype, fp] = opts.bindline.split(/\s+/)
     return new SSHFP({
       owner,
-      ttl        : parseInt(ttl, 10),
-      class      : c,
-      type       : type,
-      algorithm  : parseInt(algo, 10),
-      fptype     : parseInt(fptype, 10),
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
+      algorithm: parseInt(algo, 10),
+      fptype: parseInt(fptype, 10),
       fingerprint: fp,
     })
   }
 
   /******  EXPORTERS   *******/
 
-  toTinydns () {
+  toTinydns() {
     return this.getTinydnsGeneric(
       TINYDNS.UInt8toOctal(this.get('algorithm')) +
-      TINYDNS.UInt8toOctal(this.get('fptype')) +
-      TINYDNS.packHex(this.get('fingerprint'))
+        TINYDNS.UInt8toOctal(this.get('fptype')) +
+        TINYDNS.packHex(this.get('fingerprint')),
     )
   }
 }