@nictool/dns-resource-record 1.1.7 → 1.2.1

package/rr/nsec.js

@@ -1,15 +1,14 @@
-
 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) this.throwHelp(`NSEC: 'next domain' is required:`)
 
     this.isFullyQualified('NSEC', 'next domain', val)
     this.isValidHostname('NSEC', 'next domain', val)
@@ -18,44 +17,49 @@ 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) this.throwHelp(`NSEC: 'type bit maps' is required`)
 
     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,44 +1,43 @@
-
 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) this.throwHelp(`NSEC3: 'hash algorithm' is required`)
 
     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()}`)
+    if (!val) this.throwHelp(`NSEC3: 'flags' is required`)
 
     this.is8bitInt('NSEC3', 'flags', val)
 
     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) this.throwHelp(`NSEC3: 'iterations' is required`)
 
     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 +45,109 @@ 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) this.throwHelp(`NSEC3: 'next hashed owner name' is required`)
 
     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) this.throwHelp(`NSEC3: 'type bit maps' is required`)
 
     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(':')
-    if (n != 50) throw new Error('NSEC3 fromTinydns, invalid n')
+  fromTinydns(opts) {
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    if (n != 50) this.throwHelp('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')),
     )
   }
 }

package/rr/nsec3param.js

@@ -1,42 +1,41 @@
-
 import RR from '../rr.js'
 
 export default class NSEC3PARAM extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
     if (opts === null) return
   }
 
   /****** Resource record specific setters   *******/
-  setHashAlgoritm (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(`NSEC3PARAM: 'hash algorithm' is required, ${this.citeRFC()}`)
+    if (!val) this.throwHelp(`NSEC3PARAM: 'hash algorithm' is required`)
 
     this.is8bitInt('NSEC3PARAM', '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(`NSEC3PARAM: 'flags' is required, ${this.citeRFC()}`)
+    if (!val) this.throwHelp(`NSEC3PARAM: 'flags' is required`)
 
     this.is8bitInt('NSEC3PARAM', 'flags', val)
 
     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(`NSEC3PARAM: 'iterations' is required, ${this.citeRFC()}`)
+    if (!val) this.throwHelp(`NSEC3PARAM: 'iterations' is required`)
 
     this.is16bitInt('NSEC3PARAM', 'iterations', 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
@@ -44,41 +43,40 @@ export default class NSEC3PARAM extends RR {
     this.set('salt', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Next Secure Parameters'
   }
 
-  getRdataFields (arg) {
-    return [ 'hash algorithm', 'flags', 'iterations', 'salt' ]
+  getRdataFields(arg) {
+    return ['hash algorithm', 'flags', 'iterations', 'salt']
   }
 
-  getRFCs () {
-    return [ 5155 ]
+  getRFCs() {
+    return [5155]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 51
   }
 
   /******  IMPORTERS   *******/
 
-  fromBind (str) {
+  fromBind(str) {
     // test.example.com  3600  IN  NSEC3PARAM
-    const [ owner, ttl, c, type ] = str.split(/\s+/)
+    const [owner, ttl, c, type] = str.split(/\s+/)
     return new NSEC3PARAM({
       owner,
-      ttl                     : parseInt(ttl, 10),
-      class                   : c,
-      type                    : type,
-      'hash algorithm'        : '',
-      'flags'                 : '',
-      'iterations'            : '',
-      'salt'                  : '',
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
+      'hash algorithm': '',
+      flags: '',
+      iterations: '',
+      salt: '',
       'next hashed owner name': '',
-      'type bit maps'         : '',
+      'type bit maps': '',
     })
   }
 
   /******  EXPORTERS   *******/
-
 }

package/rr/nxt.js

@@ -0,0 +1,65 @@
+import RR from '../rr.js'
+
+export default class NXT extends RR {
+  constructor(opts) {
+    super(opts)
+    if (opts === null) return
+  }
+
+  /****** Resource record specific setters   *******/
+  setNextDomain(val) {
+    if (!val) this.throwHelp(`NXT: 'next domain' is required`)
+
+    this.isFullyQualified('NXT', 'next domain', val)
+    this.isValidHostname('NXT', 'next domain', val)
+
+    // RFC 4034: letters in the DNS names are lower cased
+    this.set('next domain', val.toLowerCase())
+  }
+
+  setTypeBitMap(val) {
+    if (!val) this.throwHelp(`NXT: 'type bit map' is required`)
+
+    this.set('type bit map', val)
+  }
+
+  getDescription() {
+    return 'Next Secure'
+  }
+
+  getRdataFields(arg) {
+    return ['next domain', 'type bit map']
+  }
+
+  getRFCs() {
+    return [2065]
+  }
+
+  getTypeId() {
+    return 30
+  }
+
+  /******  IMPORTERS   *******/
+
+  fromBind(opts) {
+    // test.example.com  3600  IN  NXT NextDomain TypeBitMap
+    const [owner, ttl, c, type, next] = opts.bindline.split(/\s+/)
+    return new NXT({
+      owner,
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
+      'next domain': next,
+      'type bit map': opts.bindline
+        .split(/\s+/)
+        .slice(5)
+        .filter(removeParens)
+        .join(' ')
+        .trim(),
+    })
+  }
+
+  /******  EXPORTERS   *******/
+}
+
+const removeParens = (a) => !['(', ')'].includes(a)

package/rr/openpgpkey.js

@@ -1,42 +1,45 @@
-
 import RR from '../rr.js'
 
 export default class OPENPGPKEY extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setPublicKey (val) {
+  setPublicKey(val) {
     this.set('public key', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'OpenPGP Public Key'
   }
 
-  getRdataFields () {
-    return [ 'public key' ]
+  getRdataFields() {
+    return ['public key']
   }
 
-  getRFCs () {
-    return [ 4880, 7929 ]
+  getRFCs() {
+    return [4880, 7929]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 61
   }
 
   /******  IMPORTERS   *******/
-  fromBind (str) {
+  fromBind(obj) {
     // test.example.com  3600  IN  OPENPGPKEY  <base64 public key>
-    const [ owner, ttl, c, type, privatekey ] = str.split(/\s+/)
+    // eslint-disable-next-line no-unused-vars
+    const [ignore, owner, ttl, c, type, publickey] = obj.bindline.match(
+      /^([\S]+)\s+(\d+)\s+(\w+)\s+(\w+)\s+([\W\w]*)$/,
+    )
+
     return new OPENPGPKEY({
       owner,
-      ttl          : parseInt(ttl, 10),
-      class        : c,
-      type         : type,
-      'private key': privatekey,
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
+      'public key': publickey.trim(),
     })
   }
 

package/rr/ptr.js

@@ -1,13 +1,12 @@
-
 import RR from '../rr.js'
 
 export default class PTR extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setDname (val) {
+  setDname(val) {
     this.isFullyQualified('PTR', 'dname', val)
     this.isValidHostname('PTR', 'dname', val)
 
@@ -15,51 +14,51 @@ export default class PTR extends RR {
     this.set('dname', val.toLowerCase())
   }
 
-  getDescription () {
+  getDescription() {
     return 'Pointer'
   }
 
-  getRdataFields (arg) {
-    return [ 'dname' ]
+  getRdataFields(arg) {
+    return ['dname']
   }
 
-  getRFCs () {
-    return [ 1035 ]
+  getRFCs() {
+    return [1035]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 12
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // ^fqdn:p:ttl:timestamp:lo
-    const [ fqdn, p, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    const [fqdn, p, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
 
     return new PTR({
-      owner    : this.fullyQualify(fqdn),
-      ttl      : parseInt(ttl, 10),
-      type     : 'PTR',
-      dname    : this.fullyQualify(p),
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'PTR',
+      dname: this.fullyQualify(p),
       timestamp: ts,
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  PTR  dname
-    const [ owner, ttl, c, type, dname ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, dname] = opts.bindline.split(/\s+/)
     return new PTR({
       owner,
-      ttl  : parseInt(ttl, 10),
+      ttl: parseInt(ttl, 10),
       class: c,
-      type : type,
+      type: type,
       dname: dname,
     })
   }
 
   /******  EXPORTERS   *******/
-  toTinydns () {
+  toTinydns() {
     return `^${this.getTinyFQDN('owner')}:${this.getTinyFQDN('dname')}:${this.getTinydnsPostamble()}\n`
   }
 }