@nictool/dns-resource-record 1.1.7 → 1.2.0

package/rr/naptr.js

@@ -1,136 +1,135 @@
-
 import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 const rdataRe = /[\r\n\t:\\/]/
 
 export default class NAPTR extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Naming Authority Pointer'
   }
 
-  getQuotedFields () {
-    return [ 'flags', 'service', 'regexp' ]
+  getQuotedFields() {
+    return ['flags', 'service', 'regexp']
   }
 
-  getRdataFields (arg) {
-    return [ 'order', 'preference', 'flags', 'service', 'regexp', 'replacement' ]
+  getRdataFields(arg) {
+    return ['order', 'preference', 'flags', 'service', 'regexp', 'replacement']
   }
 
-  getRFCs () {
-    return [ 2915, 3403 ]
+  getRFCs() {
+    return [2915, 3403]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 35
   }
 
   /****** Resource record specific setters   *******/
-  setOrder (val) {
+  setOrder(val) {
     this.is16bitInt('NAPTR', 'order', val)
     this.set('order', val)
   }
 
-  setPreference (val) {
+  setPreference(val) {
     this.is16bitInt('NAPTR', 'preference', val)
     this.set('preference', val)
   }
 
-  setFlags (val) {
-    if (![ '', 'S', 'A', 'U', 'P' ].includes(val.toUpperCase()))
-      throw new Error (`NAPTR flags are invalid, ${this.citeRFC()}`)
+  setFlags(val) {
+    if (!['', 'S', 'A', 'U', 'P'].includes(val.toUpperCase()))
+      throw new Error(`NAPTR flags are invalid, ${this.citeRFC()}`)
 
     this.set('flags', val.toUpperCase())
   }
 
-  setService (val) {
+  setService(val) {
     this.set('service', val)
   }
 
-  setRegexp (val) {
+  setRegexp(val) {
     this.set('regexp', val)
   }
 
-  setReplacement (val) {
+  setReplacement(val) {
     this.set('replacement', val)
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // NAPTR 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 != 35) throw new Error('NAPTR fromTinydns, invalid n')
 
     const binRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
 
     const rec = {
-      type      : 'NAPTR',
-      owner     : this.fullyQualify(fqdn),
-      ttl       : parseInt(ttl, 10),
-      timestamp : ts,
-      location  : loc !== '' && loc !== '\n' ? loc : '',
-      order     : binRdata.readUInt16BE(0,2),
-      preference: binRdata.readUInt16BE(2,4),
+      type: 'NAPTR',
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
+      order: binRdata.readUInt16BE(0, 2),
+      preference: binRdata.readUInt16BE(2, 4),
     }
 
     let idx = 4
-    const flagsLength = binRdata.readUInt8(idx); idx++
-    rec.flags         = binRdata.slice(idx, flagsLength).toString()
+    const flagsLength = binRdata.readUInt8(idx)
+    idx++
+    rec.flags = binRdata.slice(idx, flagsLength).toString()
     idx += flagsLength
 
-    const serviceLen  = binRdata.readUInt8(idx); idx++
-    rec.service       = binRdata.slice(idx, idx+serviceLen).toString()
+    const serviceLen = binRdata.readUInt8(idx)
+    idx++
+    rec.service = binRdata.slice(idx, idx + serviceLen).toString()
     idx += serviceLen
 
-    const regexpLen   = binRdata.readUInt8(idx); idx++
-    rec.regexp        = binRdata.slice(idx, idx+regexpLen).toString()
+    const regexpLen = binRdata.readUInt8(idx)
+    idx++
+    rec.regexp = binRdata.slice(idx, idx + regexpLen).toString()
     idx += regexpLen
 
-    const replaceLen  = binRdata.readUInt8(idx); idx++
-    rec.replacement   = binRdata.slice(idx, idx+replaceLen).toString()
+    const replaceLen = binRdata.readUInt8(idx)
+    idx++
+    rec.replacement = binRdata.slice(idx, idx + replaceLen).toString()
 
     return new NAPTR(rec)
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     const str = opts.bindline
     // test.example.com  3600  IN  NAPTR order, preference, "flags", "service", "regexp", replacement
-    const [ owner, ttl, c, type, order, preference ] = str.split(/\s+/)
-    const [ flags, service, regexp ] = str.match(/(?:").*?(?:"\s)/g)
+    const [owner, ttl, c, type, order, preference] = str.split(/\s+/)
+    const [flags, service, regexp] = str.match(/(?:").*?(?:"\s)/g)
     const replacement = str.trim().split(/\s+/).pop()
 
     const bits = {
-      owner      : owner,
-      ttl        : parseInt(ttl, 10),
-      class      : c,
-      type       : type,
-      order      : parseInt(order, 10),
-      preference : parseInt(preference, 10),
-      flags      : flags.trim().replace(/^['"]|['"]$/g, ''),
-      service    : service.trim().replace(/^['"]|['"]$/g, ''),
-      regexp     : regexp.trim().replace(/^['"]|['"]/g, ''),
+      owner: owner,
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
+      order: parseInt(order, 10),
+      preference: parseInt(preference, 10),
+      flags: flags.trim().replace(/^['"]|['"]$/g, ''),
+      service: service.trim().replace(/^['"]|['"]$/g, ''),
+      regexp: regexp.trim().replace(/^['"]|['"]/g, ''),
       replacement: replacement,
     }
     return new NAPTR(bits)
   }
 
   /******  EXPORTERS   *******/
-  toTinydns () {
-
+  toTinydns() {
     let rdata =
       TINYDNS.UInt16toOctal(this.get('order')) +
       TINYDNS.UInt16toOctal(this.get('preference')) +
-
       TINYDNS.UInt8toOctal(this.get('flags').length) +
       this.get('flags') +
-
       TINYDNS.UInt8toOctal(this.get('service').length) +
       TINYDNS.escapeOctal(rdataRe, this.get('service')) +
-
       TINYDNS.UInt8toOctal(this.get('regexp').length) +
       TINYDNS.escapeOctal(rdataRe, this.get('regexp'))
 

package/rr/ns.js

@@ -1,14 +1,13 @@
-
 import RR from '../rr.js'
 
 export default class NS extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
     if (opts === null) return
   }
 
   /****** Resource record specific setters   *******/
-  setDname (val) {
+  setDname(val) {
     if (!val) throw new Error(`NS: dname is required, ${this.citeRFC()}`)
 
     this.isFullyQualified('NS', 'dname', val)
@@ -18,57 +17,61 @@ export default class NS extends RR {
     this.set('dname', val.toLowerCase())
   }
 
-  getDescription () {
+  getDescription() {
     return 'Name Server'
   }
 
-  getRdataFields (arg) {
-    return [ 'dname' ]
+  getRdataFields(arg) {
+    return ['dname']
   }
 
-  getRFCs () {
-    return [ 1035 ]
+  getRFCs() {
+    return [1035]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 2
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // &fqdn:ip:x:ttl:timestamp:lo
     // eslint-disable-next-line no-unused-vars
-    const [ fqdn, ip, dname, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    const [fqdn, ip, dname, ttl, ts, loc] = opts.tinyline
+      .substring(1)
+      .split(':')
 
     return new NS({
-      type     : 'NS',
-      owner    : this.fullyQualify(fqdn),
-      dname    : this.fullyQualify(/\./.test(dname) ? dname : `${dname}.ns.${fqdn}`),
-      ttl      : parseInt(ttl, 10),
+      type: 'NS',
+      owner: this.fullyQualify(fqdn),
+      dname: this.fullyQualify(
+        /\./.test(dname) ? dname : `${dname}.ns.${fqdn}`,
+      ),
+      ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  NS dname
-    const [ owner, ttl, c, type, dname ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, dname] = opts.bindline.split(/\s+/)
 
     return new NS({
       owner,
-      ttl  : parseInt(ttl, 10),
+      ttl: parseInt(ttl, 10),
       class: c,
-      type : type,
+      type: type,
       dname: dname,
     })
   }
 
   /******  EXPORTERS   *******/
-  toBind (zone_opts) {
+  toBind(zone_opts) {
     return `${this.getPrefix(zone_opts)}\t${this.getFQDN('dname', zone_opts)}\n`
   }
 
-  toTinydns () {
+  toTinydns() {
     return `&${this.getTinyFQDN('owner')}::${this.getTinyFQDN('dname')}:${this.getTinydnsPostamble()}\n`
   }
 }

package/rr/nsec.js

@@ -1,15 +1,15 @@
-
 import RR from '../rr.js'
 
 export default class NSEC extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
     if (opts === null) return
   }
 
   /****** Resource record specific setters   *******/
-  setNextDomain (val) {
-    if (!val) throw new Error(`NSEC: 'next domain' is required:, ${this.citeRFC()}`)
+  setNextDomain(val) {
+    if (!val)
+      throw new Error(`NSEC: 'next domain' is required:, ${this.citeRFC()}`)
 
     this.isFullyQualified('NSEC', 'next domain', val)
     this.isValidHostname('NSEC', 'next domain', val)
@@ -18,44 +18,50 @@ export default class NSEC extends RR {
     this.set('next domain', val.toLowerCase())
   }
 
-  setTypeBitMaps (val) {
-    if (!val) throw new Error(`NSEC: 'type bit maps' is required, ${this.citeRFC()}`)
+  setTypeBitMaps(val) {
+    if (!val)
+      throw new Error(`NSEC: 'type bit maps' is required, ${this.citeRFC()}`)
 
     this.set('type bit maps', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Next Secure'
   }
 
-  getRdataFields (arg) {
-    return [ 'next domain', 'type bit maps' ]
+  getRdataFields(arg) {
+    return ['next domain', 'type bit maps']
   }
 
-  getRFCs () {
-    return [ 4034 ]
+  getRFCs() {
+    return [4034]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 47
   }
 
   /******  IMPORTERS   *******/
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  NSEC NextDomain TypeBitMaps
-    const [ owner, ttl, c, type, next ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, next] = opts.bindline.split(/\s+/)
     return new NSEC({
       owner,
-      ttl            : parseInt(ttl, 10),
-      class          : c,
-      type           : type,
-      'next domain'  : next,
-      'type bit maps': opts.bindline.split(/\s+/).slice(5).filter(removeParens).join(' ').trim(),
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
+      'next domain': next,
+      'type bit maps': opts.bindline
+        .split(/\s+/)
+        .slice(5)
+        .filter(removeParens)
+        .join(' ')
+        .trim(),
     })
   }
 
   /******  EXPORTERS   *******/
 }
 
-const removeParens = a => ![ '(',')' ].includes(a)
+const removeParens = (a) => !['(', ')'].includes(a)

package/rr/nsec3.js

@@ -1,26 +1,26 @@
-
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class NSEC3 extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
     if (opts === null) return
   }
 
   /****** Resource record specific setters   *******/
-  setHashAlgorithm (val) {
+  setHashAlgorithm(val) {
     // Hash Algorithm is a single octet.
     // The Hash Algorithm field is represented as an unsigned decimal integer.
-    if (!val) throw new Error(`NSEC3: 'hash algorithm' is required, ${this.citeRFC()}`)
+    if (!val)
+      throw new Error(`NSEC3: 'hash algorithm' is required, ${this.citeRFC()}`)
 
     this.is8bitInt('NSEC3', 'hash algorithm', val)
 
     this.set('hash algorithm', val)
   }
 
-  setFlags (val) {
+  setFlags(val) {
     // The Flags field is represented as an unsigned decimal integer.
     if (!val) throw new Error(`NSEC3: 'flags' is required, ${this.citeRFC()}`)
 
@@ -29,16 +29,17 @@ export default class NSEC3 extends RR {
     this.set('flags', val)
   }
 
-  setIterations (val) {
+  setIterations(val) {
     // The Iterations field is represented as an unsigned decimal integer. 0-65535
-    if (!val) throw new Error(`NSEC3: 'iterations' is required, ${this.citeRFC()}`)
+    if (!val)
+      throw new Error(`NSEC3: 'iterations' is required, ${this.citeRFC()}`)
 
     this.is16bitInt('NSEC3', 'flags', val)
 
     this.set('iterations', val)
   }
 
-  setSalt (val) {
+  setSalt(val) {
     // The Salt field is represented as a sequence of case-insensitive
     // hexadecimal digits.  Whitespace is not allowed within the
     // sequence.  The Salt field is represented as "-" (without the
@@ -46,95 +47,113 @@ export default class NSEC3 extends RR {
     this.set('salt', val)
   }
 
-  setNextHashedOwnerName (val) {
+  setNextHashedOwnerName(val) {
     // The Next Hashed Owner Name field is represented as an unpadded
     // sequence of case-insensitive base32 digits, without whitespace
-    if (!val) throw new Error(`NSEC3: 'next hashed owner name' is required, ${this.citeRFC()}`)
+    if (!val)
+      throw new Error(
+        `NSEC3: 'next hashed owner name' is required, ${this.citeRFC()}`,
+      )
 
     this.set('next hashed owner name', val)
   }
 
-  setTypeBitMaps (val) {
+  setTypeBitMaps(val) {
     // The Type Bit Maps field is represented as a sequence of RR type mnemonics.
-    if (!val) throw new Error(`NSEC3: 'type bit maps' is required, ${this.citeRFC()}`)
+    if (!val)
+      throw new Error(`NSEC3: 'type bit maps' is required, ${this.citeRFC()}`)
 
     this.set('type bit maps', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Next Secure'
   }
 
-  getRdataFields (arg) {
-    return [ 'hash algorithm', 'flags', 'iterations', 'salt', 'next hashed owner name', 'type bit maps' ]
+  getRdataFields(arg) {
+    return [
+      'hash algorithm',
+      'flags',
+      'iterations',
+      'salt',
+      'next hashed owner name',
+      'type bit maps',
+    ]
   }
 
-  getRFCs () {
-    return [ 5155, 9077 ]
+  getRFCs() {
+    return [5155, 9077]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 50
   }
 
   /******  IMPORTERS   *******/
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com. 3600 IN NSEC3 1 1 12 aabbccdd (2vptu5timamqttgl4luu9kg21e0aor3s A RRSIG)
-    const [ owner, ttl, c, type, ha, flags, iterations, salt ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, ha, flags, iterations, salt] =
+      opts.bindline.split(/\s+/)
     const rdata = opts.bindline.split(/\(|\)/)[1]
 
     return new NSEC3({
       owner,
-      ttl                     : parseInt(ttl, 10),
-      class                   : c,
-      type                    : type,
-      'hash algorithm'        : parseInt(ha, 10),
-      flags                   : parseInt(flags, 10),
-      iterations              : parseInt(iterations, 10),
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
+      'hash algorithm': parseInt(ha, 10),
+      flags: parseInt(flags, 10),
+      iterations: parseInt(iterations, 10),
       salt,
       'next hashed owner name': rdata.split(/\s+/)[0],
-      'type bit maps'         : rdata.split(/\s+/).slice(1).join('\t'),
+      'type bit maps': rdata.split(/\s+/).slice(1).join('\t'),
     })
   }
 
-  fromTinydns (opts) {
-    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+  fromTinydns(opts) {
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
     if (n != 50) throw new Error('NSEC3 fromTinydns, invalid n')
 
     const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
 
     return new NSEC3({
-      owner                   : this.fullyQualify(fqdn),
-      ttl                     : parseInt(ttl, 10),
-      type                    : 'NSEC3',
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'NSEC3',
       'hash algorithm': bytes.readUInt8(0),
-      flags                   : bytes.readUInt8(1),
-      iterations              : bytes.readUInt16BE(2),
+      flags: bytes.readUInt8(1),
+      iterations: bytes.readUInt16BE(2),
       // salt                    : ,
       // 'next hashed owner name': ,
       // 'type bit maps'         : ,
-      timestamp               : ts,
-      location                : loc !== '' && loc !== '\n' ? loc : '',
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
   /******  EXPORTERS   *******/
 
-  toBind (zone_opts) {
-    return `${this.getFQDN('owner', zone_opts)}\t${this.get('ttl')}\t${this.get('class')}\tNSEC3${this.getRdataFields().slice(0,4).map(f => '\t' + this.get(f)).join('')}\t(${this.getRdataFields().slice(4).map(f => this.get(f)).join('\t')})\n`
+  toBind(zone_opts) {
+    return `${this.getFQDN('owner', zone_opts)}\t${this.get('ttl')}\t${this.get('class')}\tNSEC3${this.getRdataFields()
+      .slice(0, 4)
+      .map((f) => '\t' + this.get(f))
+      .join('')}\t(${this.getRdataFields()
+      .slice(4)
+      .map((f) => this.get(f))
+      .join('\t')})\n`
   }
 
-  toTinydns () {
+  toTinydns() {
     const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
 
     return this.getTinydnsGeneric(
       TINYDNS.UInt8toOctal(this.get('hash algorithm')) +
-      TINYDNS.UInt8toOctal(this.get('flags')) +
-      TINYDNS.UInt16toOctal(this.get('iterations')) +
-      TINYDNS.escapeOctal(dataRe, this.get('salt')) +
-      TINYDNS.escapeOctal(dataRe, this.get('next hashed owner name')) +
-      TINYDNS.escapeOctal(dataRe, this.get('type bit maps'))
+        TINYDNS.UInt8toOctal(this.get('flags')) +
+        TINYDNS.UInt16toOctal(this.get('iterations')) +
+        TINYDNS.escapeOctal(dataRe, this.get('salt')) +
+        TINYDNS.escapeOctal(dataRe, this.get('next hashed owner name')) +
+        TINYDNS.escapeOctal(dataRe, this.get('type bit maps')),
     )
   }
 }