@nictool/dns-resource-record 1.1.7 → 1.2.1

package/rr/caa.js

@@ -1,110 +1,122 @@
-
 import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class CAA extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setFlags (val) {
+  setFlags(val) {
     this.is8bitInt('CAA', 'flags', val)
 
-    if (![ 0, 128 ].includes(val)) {
-      throw new Error(`CAA flags ${val} not recognized, ${this.citeRFC()}`)
+    if (![0, 128].includes(val)) {
+      this.throwHelp(`CAA flags ${val} not recognized`)
     }
 
     this.set('flags', val)
   }
 
-  setTag (val) {
-    if (typeof val !== 'string'
-      || val.length < 1
-      || /[^a-z0-9]/.test(val))
-      throw new Error(`CAA tag must be a sequence of ASCII letters and numbers in lowercase, ${this.citeRFC()}`)
+  setTag(val) {
+    if (typeof val !== 'string' || val.length < 1 || /[^a-z0-9]/.test(val))
+      this.throwHelp(
+        `CAA tag must be a sequence of ASCII letters and numbers in lowercase`,
+      )
 
-    if (![ 'issue', 'issuewild', 'iodef' ].includes(val)) {
-      throw new Error(`CAA tag ${val} not recognized: ${this.citeRFC()}`)
+    if (!['issue', 'issuewild', 'iodef'].includes(val)) {
+      this.throwHelp(`CAA tag ${val} not recognized`)
     }
     this.set('tag', val)
   }
 
-  setValue (val) {
+  setValue(val) {
     // either (2) a quoted string or
     // (1) a contiguous set of characters without interior spaces
     if (this.isQuoted(val)) {
       val = val.replace(/^["']|["']$/g, '') // strip quotes
-    }
-    else {
-      // if (/\s/.test(val)) throw new Error(`CAA value may not have spaces unless quoted: RFC 8659`)
+    } else {
+      // if (/\s/.test(val)) this.throwHelp(`CAA value may not have spaces unless quoted`)
     }
 
     // check if val starts with one of iodefSchemes
     if (this.get('tag') === 'iodef') {
-      const iodefSchemes = [ 'mailto:', 'http:', 'https:' ]
-      if (!iodefSchemes.filter(s => val.startsWith(s)).length) {
-        throw new Error(`CAA value must have valid iodefScheme prefix, ${this.citeRFC()}`)
+      const iodefSchemes = ['mailto:', 'http:', 'https:']
+      if (!iodefSchemes.filter((s) => val.startsWith(s)).length) {
+        this.throwHelp(`CAA value must have valid iodefScheme prefix`)
       }
     }
 
     this.set('value', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Certification Authority Authorization'
   }
 
-  getQuotedFields () {
-    return [ 'value' ]
+  getQuotedFields() {
+    return ['value']
   }
 
-  getRdataFields (arg) {
-    return [ 'flags', 'tag', 'value' ]
+  getRdataFields(arg) {
+    return ['flags', 'tag', 'value']
   }
 
-  getRFCs () {
-    return [ 6844, 8659 ]
+  getRFCs() {
+    return [6844, 8659]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 257
   }
 
+  getCanonical() {
+    return {
+      owner: 'example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'CAA',
+      flags: 0,
+      tag: 'issue',
+      value: 'http://letsencrypt.org',
+    }
+  }
+
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // CAA via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
-    if (n != 257) throw new Error('CAA fromTinydns, invalid n')
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    if (n != 257) this.throwHelp('CAA fromTinydns, invalid n')
 
-    const flags  = TINYDNS.octalToUInt8(rdata.substring(0, 4))
+    const flags = TINYDNS.octalToUInt8(rdata.substring(0, 4))
     const taglen = TINYDNS.octalToUInt8(rdata.substring(4, 8))
 
-    const unescaped   = TINYDNS.octalToChar(rdata.substring(8))
-    const tag         = unescaped.substring(0, taglen)
+    const unescaped = TINYDNS.octalToChar(rdata.substring(8))
+    const tag = unescaped.substring(0, taglen)
     const fingerprint = unescaped.substring(taglen)
 
     return new CAA({
-      owner    : this.fullyQualify(fqdn),
-      ttl      : parseInt(ttl, 10),
-      type     : 'CAA',
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'CAA',
       flags,
       tag,
-      value    : fingerprint,
+      value: fingerprint,
       timestamp: ts,
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  CAA flags, tags, value
-    const fields = opts.bindline.match(/^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+(\w+)\s+("[^"]+"|[^\s]+?)\s*$/i)
-    if (!fields) throw new Error(`unable to parse: ${opts.bindline}`)
+    const fields = opts.bindline.match(
+      /^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+(\w+)\s+("[^"]+"|[^\s]+?)\s*$/i,
+    )
+    if (!fields) this.throwHelp(`unable to parse: ${opts.bindline}`)
 
-    const [ owner, ttl, c, type, flags, tag, value ] = fields.slice(1)
+    const [owner, ttl, c, type, flags, tag, value] = fields.slice(1)
     return new CAA({
       owner,
-      ttl  : parseInt(ttl, 10),
+      ttl: parseInt(ttl, 10),
       class: c,
       type,
       flags: parseInt(flags, 10),
@@ -115,7 +127,7 @@ export default class CAA extends RR {
 
   /******  EXPORTERS   *******/
 
-  toTinydns () {
+  toTinydns() {
     let rdata = ''
     rdata += TINYDNS.UInt8toOctal(this.get('flags'))
 

package/rr/cert.js

@@ -1,13 +1,12 @@
-
 import RR from '../rr.js'
 
 export default class CERT extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setCertType (val) {
+  setCertType(val) {
     // The type field is the certificate type
     // the type field as an unsigned decimal integer or as a mnemonic symbol
     // this.is16bitInt('CERT', 'type', val)
@@ -15,7 +14,7 @@ export default class CERT extends RR {
     this.set('cert type', val)
   }
 
-  setKeyTag (val) {
+  setKeyTag(val) {
     // The key tag field is the 16-bit value
     // The key tag field is represented as an unsigned decimal integer.
 
@@ -24,7 +23,7 @@ export default class CERT extends RR {
     this.set('key tag', val)
   }
 
-  setAlgorithm (val) {
+  setAlgorithm(val) {
     // The algorithm field has the same meaning as the algorithm field in DNSKEY
     // The algorithm field is represented as an unsigned decimal integer
     this.is8bitInt('CERT', 'algorithm', val)
@@ -32,41 +31,44 @@ export default class CERT extends RR {
     this.set('algorithm', val)
   }
 
-  setCertificate (val) {
+  setCertificate(val) {
     // certificate/CRL portion is represented in base 64 [16] and may be
     // divided into any number of white-space-separated substrings
     this.set('certificate', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Certificate'
   }
 
-  getRdataFields () {
-    return [ 'cert type', 'key tag', 'algorithm', 'certificate' ]
+  getRdataFields() {
+    return ['cert type', 'key tag', 'algorithm', 'certificate']
   }
 
-  getRFCs () {
-    return [ 2538, 4398 ]
+  getRFCs() {
+    return [2538, 4398]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 37
   }
 
   /******  IMPORTERS   *******/
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  CERT  certtype, keytag, algo, cert
-    const [ owner, ttl, c, type, certtype, keytag, algo, certificate  ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, certtype, keytag, algo, certificate] =
+      opts.bindline.split(/\s+/)
     return new CERT({
       owner,
-      ttl        : parseInt(ttl, 10),
-      class      : c,
+      ttl: parseInt(ttl, 10),
+      class: c,
       type,
-      'cert type': /^[0-9]+$/.test(certtype) ? parseInt(certtype, 10) : certtype,
-      'key tag'  : parseInt(keytag,   10),
-      algorithm  : parseInt(algo, 10),
+      'cert type': /^[0-9]+$/.test(certtype)
+        ? parseInt(certtype, 10)
+        : certtype,
+      'key tag': parseInt(keytag, 10),
+      algorithm: parseInt(algo, 10),
       certificate,
     })
   }

package/rr/cname.js

@@ -1,22 +1,21 @@
-
-import net from 'net'
+import net from 'node:net'
 
 import RR from '../rr.js'
 
 export default class CNAME extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setCname (val) {
+  setCname(val) {
     // A <domain-name> which specifies the canonical or primary
     // name for the owner.  The owner name is an alias.
 
-    if (!val) throw new Error('CNAME: cname is required')
+    if (!val) this.throwHelp('CNAME: cname is required')
 
     if (net.isIPv4(val) || net.isIPv6(val))
-      throw new Error(`CNAME: cname must be a FQDN: RFC 2181`)
+      this.throwHelp(`CNAME: cname must be a FQDN: RFC 2181`)
 
     if (!this.isFullyQualified('CNAME', 'cname', val)) return
     if (!this.isValidHostname('CNAME', 'cname', val)) return
@@ -25,43 +24,43 @@ export default class CNAME extends RR {
     this.set('cname', val.toLowerCase())
   }
 
-  getDescription () {
+  getDescription() {
     return 'Canonical Name'
   }
 
-  getRdataFields (arg) {
-    return [ 'cname' ]
+  getRdataFields(arg) {
+    return ['cname']
   }
 
-  getRFCs () {
-    return [ 1035, 2181 ]
+  getRFCs() {
+    return [1035, 2181]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 5
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // Cfqdn: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 CNAME({
-      owner    : this.fullyQualify(fqdn),
-      ttl      : parseInt(ttl, 10),
-      type     : 'CNAME',
-      cname    : this.fullyQualify(p),
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'CNAME',
+      cname: this.fullyQualify(p),
       timestamp: ts,
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  CNAME  ...
-    const [ owner, ttl, c, type, cname ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, cname] = opts.bindline.split(/\s+/)
     return new CNAME({
       owner,
-      ttl  : parseInt(ttl, 10),
+      ttl: parseInt(ttl, 10),
       class: c,
       type,
       cname,
@@ -70,7 +69,7 @@ export default class CNAME extends RR {
 
   /******  EXPORTERS   *******/
 
-  toTinydns () {
+  toTinydns() {
     return `C${this.getTinyFQDN('owner')}:${this.get('cname')}:${this.getTinydnsPostamble()}\n`
   }
 }

package/rr/dname.js

@@ -1,19 +1,19 @@
-import net from 'net'
+import net from 'node:net'
 
 import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class DNAME extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setTarget (val) {
-    if (!val) throw new Error('DNAME: target is required')
+  setTarget(val) {
+    if (!val) this.throwHelp('DNAME: target is required')
 
     if (net.isIPv4(val) || net.isIPv6(val))
-      throw new Error(`DNAME: target must be a domain name, ${this.citeRFC()}`)
+      this.throwHelp(`DNAME: target must be a domain name`)
 
     this.isFullyQualified('DNAME', 'target', val)
     this.isValidHostname('DNAME', 'target', val)
@@ -22,44 +22,44 @@ export default class DNAME extends RR {
     this.set('target', val.toLowerCase())
   }
 
-  getDescription () {
+  getDescription() {
     return 'Delegation Name'
   }
 
-  getRdataFields (arg) {
-    return [ 'target' ]
+  getRdataFields(arg) {
+    return ['target']
   }
 
-  getRFCs () {
-    return [ 2672, 6672 ]
+  getRFCs() {
+    return [2672, 6672]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 39
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // DNAME via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
-    if (n != 39) throw new Error('DNAME fromTinydns, invalid n')
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    if (n != 39) this.throwHelp('DNAME fromTinydns, invalid n')
 
     return new DNAME({
-      type     : 'DNAME',
-      owner    : this.fullyQualify(fqdn),
-      target   : (TINYDNS.unpackDomainName(rdata))[0],
-      ttl      : parseInt(ttl, 10),
+      type: 'DNAME',
+      owner: this.fullyQualify(fqdn),
+      target: TINYDNS.unpackDomainName(rdata)[0],
+      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  DNAME  ...
-    const [ owner, ttl, c, type, target ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, target] = opts.bindline.split(/\s+/)
     return new DNAME({
       owner,
-      ttl  : parseInt(ttl, 10),
+      ttl: parseInt(ttl, 10),
       class: c,
       type,
       target,
@@ -67,7 +67,7 @@ export default class DNAME extends RR {
   }
 
   /******  EXPORTERS   *******/
-  toTinydns () {
+  toTinydns() {
     const rdata = TINYDNS.packDomainName(this.get('target'))
     return this.getTinydnsGeneric(rdata)
   }

package/rr/dnskey.js

@@ -1,117 +1,119 @@
-
 import RR from '../rr.js'
 
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class DNSKEY extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setFlags (val) {
+  setFlags(val) {
     // a 2 octet Flags Field
     this.is16bitInt('DNSKEY', 'flags', val)
 
     // the possible values are: 0, 256, and 257; RFC 4034
-    if (![ 0, 256, 257 ].includes(val)) throw new Error(`DNSKEY: flags invalid, ${this.citeRFC()}`)
+    if (![0, 256, 257].includes(val)) this.throwHelp(`DNSKEY: flags invalid`)
 
     this.set('flags', val)
   }
 
-  setProtocol (val) {
+  setProtocol(val) {
     // 1 octet
     this.is8bitInt('DNSKEY', 'protocol', val)
 
     // The Protocol Field MUST be represented as an unsigned decimal integer with a value of 3.
-    if (![ 3 ].includes(val)) throw new Error(`DNSKEY: protocol invalid, ${this.citeRFC()}`)
+    if (![3].includes(val)) this.throwHelp(`DNSKEY: protocol invalid`)
 
     this.set('protocol', val)
   }
 
-  setAlgorithm (val) {
+  setAlgorithm(val) {
     // 1 octet
     this.is8bitInt('DNSKEY', 'algorithm', val)
 
     // https://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml
     // 1=RSA/MD5, 2=DH, 3=DSA/SHA-1, 4=EC, 5=RSA/SHA-1
-    if (![ ...Array(16).keys(),253,254 ].includes(val))
-      console.error(`DNSKEY: algorithm (${val}) not recognized, ${this.citeRFC()}`)
+    if (![...Array(16).keys(), 253, 254].includes(val))
+      console.error(`DNSKEY: algorithm (${val}) not recognized`)
 
     this.set('algorithm', val)
   }
 
-  setPublickey (val) {
-    if (!val) throw new Error(`DNSKEY: publickey is required, ${this.citeRFC()}`)
+  setPublickey(val) {
+    if (!val) this.throwHelp(`DNSKEY: publickey is required`)
 
     this.set('publickey', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'DNS Public Key'
   }
 
-  getRdataFields (arg) {
-    return [ 'flags', 'protocol', 'algorithm', 'publickey' ]
+  getRdataFields(arg) {
+    return ['flags', 'protocol', 'algorithm', 'publickey']
   }
 
-  getRFCs () {
-    return [ 4034, 6014, 8624 ]
+  getRFCs() {
+    return [4034, 6014, 8624]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 48
   }
 
   /******  IMPORTERS   *******/
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  DNSKEY Flags Protocol Algorithm PublicKey
-    const match = opts.bindline.match(/^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+\s*(.*?)\s*$/)
-    if (!match) throw new Error(`unable to parse DNSKEY: ${opts.bindline}`)
-    const [ owner, ttl, c, type, flags, protocol, algorithm, publickey ] = match.slice(1)
+    const match = opts.bindline.match(
+      /^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+\s*(.*?)\s*$/,
+    )
+    if (!match) this.throwHelp(`unable to parse DNSKEY: ${opts.bindline}`)
+    const [owner, ttl, c, type, flags, protocol, algorithm, publickey] =
+      match.slice(1)
 
     return new DNSKEY({
       owner,
-      ttl      : parseInt(ttl, 10),
-      class    : c,
-      type     : type,
-      flags    : parseInt(flags,     10),
-      protocol : parseInt(protocol, 10),
-      algorithm: parseInt(algorithm,  10),
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
+      flags: parseInt(flags, 10),
+      protocol: parseInt(protocol, 10),
+      algorithm: parseInt(algorithm, 10),
       publickey: publickey,
     })
   }
 
-  fromTinydns (opts) {
-    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
-    if (n != 48) throw new Error('DNSKEY fromTinydns, invalid n')
+  fromTinydns(opts) {
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    if (n != 48) this.throwHelp('DNSKEY fromTinydns, invalid n')
 
     const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
 
     return new DNSKEY({
-      owner      : this.fullyQualify(fqdn),
-      ttl        : parseInt(ttl, 10),
-      type       : 'DNSKEY',
-      flags      : bytes.readUInt16BE(0),
-      protocol   : bytes.readUInt8(2),
-      'algorithm': bytes.readUInt8(3),
-      'publickey': bytes.slice(4).toString(),
-      timestamp  : ts,
-      location   : loc !== '' && loc !== '\n' ? loc : '',
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'DNSKEY',
+      flags: bytes.readUInt16BE(0),
+      protocol: bytes.readUInt8(2),
+      algorithm: bytes.readUInt8(3),
+      publickey: bytes.slice(4).toString(),
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
   /******  EXPORTERS   *******/
 
-  toTinydns () {
+  toTinydns() {
     const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
 
     return this.getTinydnsGeneric(
       TINYDNS.UInt16toOctal(this.get('flags')) +
-      TINYDNS.UInt8toOctal(this.get('protocol')) +
-      TINYDNS.UInt8toOctal(this.get('algorithm')) +
-      TINYDNS.escapeOctal(dataRe, this.get('publickey'))
+        TINYDNS.UInt8toOctal(this.get('protocol')) +
+        TINYDNS.UInt8toOctal(this.get('algorithm')) +
+        TINYDNS.escapeOctal(dataRe, this.get('publickey')),
     )
   }
 }