@nictool/dns-resource-record 1.1.7 → 1.2.1

package/rr/loc.js

@@ -1,9 +1,9 @@
-
 import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
-const REF = {  // RFC 1876
-  LATLON  : 2**31,  // LAT equator, LON prime meridian
+const REF = {
+  // RFC 1876
+  LATLON: 2 ** 31, // LAT equator, LON prime meridian
   ALTITUDE: 100000 * 100, // reference spheroid used by GPS, in cm
 }
 
@@ -14,13 +14,13 @@ const CONV = {
 }
 
 export default class LOC extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setAddress (val) {
-    if (!val) throw new Error('LOC: address is required')
+  setAddress(val) {
+    if (!val) this.throwHelp('LOC: address is required')
 
     /*
     ... LOC ( d1 [m1 [s1]] {"N"|"S"} d2 [m2 [s2]]
@@ -32,53 +32,53 @@ export default class LOC extends RR {
     this.set('address', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Location'
   }
 
-  getRdataFields (arg) {
-    return [ 'address' ]
+  getRdataFields(arg) {
+    return ['address']
   }
 
-  getRFCs () {
-    return [ 1876 ]
+  getRFCs() {
+    return [1876]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 29
   }
 
-  parseLoc (string) {
-
+  parseLoc(string) {
     // d1 [m1 [s1]]
     const dms = '(\\d+)\\s+(?:(\\d+)\\s+)?(?:([\\d.]+)\\s+)?'
 
     // alt["m"] [siz["m"] [hp["m"] [vp["m"]]]]
-    const alt = '(-?[\\d.]+)m?(?:\\s+([\\d.]+)m?)?(?:\\s+([\\d.]+)m?)?(?:\\s+([\\d.]+)m?)?'
+    const alt =
+      '(-?[\\d.]+)m?(?:\\s+([\\d.]+)m?)?(?:\\s+([\\d.]+)m?)?(?:\\s+([\\d.]+)m?)?'
 
     // put them all together
     const locRe = new RegExp(`^${dms}(N|S)\\s+${dms}(E|W)\\s+${alt}`, 'i')
     const r = string.match(locRe)
-    if (!r) throw new Error('LOC address: invalid format, see RFC 1876')
+    if (!r) this.throwHelp('LOC address: invalid format, see RFC 1876')
 
     const loc = {
       latitude: {
-        degrees   : r[1],
-        minutes   : r[2],
-        seconds   : r[3],
+        degrees: r[1],
+        minutes: r[2],
+        seconds: r[3],
         hemisphere: r[4].toUpperCase(),
       },
       longitude: {
-        degrees   : r[5],
-        minutes   : r[6],
-        seconds   : r[7],
+        degrees: r[5],
+        minutes: r[6],
+        seconds: r[7],
         hemisphere: r[8].toUpperCase(),
       },
-      altitude : r[9] * 100,  // m -> cm
-      size     : r[10] * 100,
+      altitude: r[9] * 100, // m -> cm
+      size: r[10] * 100,
       precision: {
         horizontal: r[11] * 100,
-        vertical  : r[12] * 100,
+        vertical: r[12] * 100,
       },
     }
 
@@ -86,48 +86,61 @@ export default class LOC extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // LOC via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [ fqdn, n, rdata, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
-    if (n != 29) throw new Error('LOC fromTinydns, invalid n')
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    if (n != 29) this.throwHelp('LOC fromTinydns, invalid n')
 
     // divide by 100 is to convert cm to meters
     const l = {
-      version  : TINYDNS.octalToUInt8(rdata.substring(0, 4)),
-      size     : this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(4, 8))),
+      version: TINYDNS.octalToUInt8(rdata.substring(0, 4)),
+      size: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(4, 8))),
       precision: {
-        horizontal: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring( 8, 12))),
-        vertical  : this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(12, 16))),
+        horizontal: this.fromExponent(
+          TINYDNS.octalToUInt8(rdata.substring(8, 12)),
+        ),
+        vertical: this.fromExponent(
+          TINYDNS.octalToUInt8(rdata.substring(12, 16)),
+        ),
       },
-      latitude : this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.substring(16, 32)), 'lat'),
-      longitude: this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.substring(32, 48)), 'lon'),
-      altitude : TINYDNS.octalToUInt32(rdata.substring(48, 64)) - REF.ALTITUDE,
+      latitude: this.arcSecToDMS(
+        TINYDNS.octalToUInt32(rdata.substring(16, 32)),
+        'lat',
+      ),
+      longitude: this.arcSecToDMS(
+        TINYDNS.octalToUInt32(rdata.substring(32, 48)),
+        'lon',
+      ),
+      altitude: TINYDNS.octalToUInt32(rdata.substring(48, 64)) - REF.ALTITUDE,
     }
 
     return new LOC({
-      type     : 'LOC',
-      owner    : this.fullyQualify(fqdn),
-      address  : this.toHuman(l),
-      ttl      : parseInt(ttl, 10),
+      type: 'LOC',
+      owner: this.fullyQualify(fqdn),
+      address: this.toHuman(l),
+      ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
-    const [ owner, ttl, c, type ] = opts.bindline.split(/\s+/)
+  fromBind(opts) {
+    const [owner, ttl, c, type] = opts.bindline.split(/\s+/)
 
     return new LOC({
       owner,
-      ttl    : parseInt(ttl, 10),
-      class  : c,
-      type   : type,
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type: type,
       address: opts.bindline.split(/\s+/).slice(4).join(' ').trim(),
     })
   }
 
-  dmsToArcSec (obj) {
-    let retval = (obj.degrees * CONV.deg) + ((obj.minutes || 0) * CONV.min) + ((obj.seconds || 0) * CONV.sec)
+  dmsToArcSec(obj) {
+    let retval =
+      obj.degrees * CONV.deg +
+      (obj.minutes || 0) * CONV.min +
+      (obj.seconds || 0) * CONV.sec
     switch (obj.hemisphere.toUpperCase()) {
       case 'W':
       case 'S':
@@ -138,7 +151,7 @@ export default class LOC extends RR {
     return retval
   }
 
-  arcSecToDMS (rawmsec, latlon) {
+  arcSecToDMS(rawmsec, latlon) {
     let msec = Math.abs(rawmsec - REF.LATLON)
     // console.log(`rawmsec: ${rawmsec}, abs msec: ${msec}`)
 
@@ -160,19 +173,19 @@ export default class LOC extends RR {
         hem = rawmsec >= REF.LATLON ? 'E' : 'W'
         break
       default:
-        throw new Error('unknown or missing hemisphere')
+        this.throwHelp('unknown or missing hemisphere')
     }
 
-    return `${deg} ${min} ${sec}${msec ? '.'+msec : ''} ${hem}`
+    return `${deg} ${min} ${sec}${msec ? '.' + msec : ''} ${hem}`
   }
 
-  fromExponent (prec) {
+  fromExponent(prec) {
     const mantissa = ((prec >> 4) & 0x0f) % 10
     const exponent = ((prec >> 0) & 0x0f) % 10
     return mantissa * Math.pow(10, exponent)
   }
 
-  toExponent (val) {
+  toExponent(val) {
     /*
      RFC 1876, ... expressed as a pair of four-bit unsigned
      integers, each ranging from zero to nine, with the most
@@ -188,22 +201,22 @@ export default class LOC extends RR {
     return (parseInt(val) << 4) | (exponent & 0x0f)
   }
 
-  toHuman (obj) {
-    let r = `${obj.latitude} ${obj.longitude} ${(obj.altitude/100)}m`
-    if (obj.size)                 r += ` ${obj.size/100}m`
+  toHuman(obj) {
+    let r = `${obj.latitude} ${obj.longitude} ${obj.altitude / 100}m`
+    if (obj.size) r += ` ${obj.size / 100}m`
     if (obj.precision.horizontal) r += ` ${obj.precision.horizontal / 100}m`
-    if (obj.precision.vertical  ) r += ` ${obj.precision.vertical / 100}m`
+    if (obj.precision.vertical) r += ` ${obj.precision.vertical / 100}m`
     return r
   }
 
   /******  EXPORTERS   *******/
 
-  toTinydns () {
+  toTinydns() {
     const loc = this.parseLoc(this.get('address'))
 
     // LOC format declares in meters, tinydns uses cm (hence * 100)
     let rdata = ''
-    rdata += TINYDNS.UInt8toOctal(0)  // version
+    rdata += TINYDNS.UInt8toOctal(0) // version
     rdata += TINYDNS.UInt8toOctal(this.toExponent(loc.size))
     rdata += TINYDNS.UInt8toOctal(this.toExponent(loc.precision.horizontal))
     rdata += TINYDNS.UInt8toOctal(this.toExponent(loc.precision.vertical))

package/rr/mx.js

@@ -1,25 +1,25 @@
-
-import net from 'net'
+import net from 'node:net'
 
 import RR from '../rr.js'
 
 export default class MX extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setPreference (val) {
+  setPreference(val) {
     if (val === undefined) val = this?.default?.preference
+    if (val === undefined) this.throwHelp('MX: preference is required')
     this.is16bitInt('MX', 'preference', val)
     this.set('preference', val)
   }
 
-  setExchange (val) {
-    if (!val) throw new Error('MX: exchange is required')
+  setExchange(val) {
+    if (!val) this.throwHelp('MX: exchange is required')
 
     if (net.isIPv4(val) || net.isIPv6(val))
-      throw new Error(`MX: exchange must be a FQDN, ${this.citeRFC()}`)
+      this.throwHelp(`MX: exchange must be a FQDN`)
 
     this.isFullyQualified('MX', 'exchange', val)
     this.isValidHostname('MX', 'exchange', val)
@@ -28,47 +28,61 @@ export default class MX extends RR {
     this.set('exchange', val.toLowerCase())
   }
 
-  getDescription () {
+  getDescription() {
     return 'Mail Exchanger'
   }
 
-  getRdataFields (arg) {
-    return [ 'preference', 'exchange' ]
+  getRdataFields(arg) {
+    return ['preference', 'exchange']
   }
 
-  getRFCs () {
-    return [ 1035, 2181, 7505 ]
+  getRFCs() {
+    return [1035, 2181, 7505]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 15
   }
 
+  getCanonical() {
+    return {
+      owner: 'example.com.',
+      ttl: 43200,
+      class: 'IN',
+      type: 'MX',
+      preference: 0,
+      exchange: 'mail.example.com.',
+    }
+  }
+
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // @fqdn:ip:x:dist:ttl:timestamp:lo
     // eslint-disable-next-line no-unused-vars
-    const [ owner, ip, x, preference, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    const [owner, ip, x, preference, ttl, ts, loc] = opts.tinyline
+      .substring(1)
+      .split(':')
 
     return new MX({
-      type      : 'MX',
-      owner     : this.fullyQualify(owner),
-      exchange  : this.fullyQualify(/\./.test(x) ? x : `${x}.mx.${owner}`),
+      type: 'MX',
+      owner: this.fullyQualify(owner),
+      exchange: this.fullyQualify(/\./.test(x) ? x : `${x}.mx.${owner}`),
       preference: parseInt(preference, 10) || 0,
-      ttl       : parseInt(ttl, 10),
-      timestamp : ts,
-      location  : loc !== '' && loc !== '\n' ? loc : '',
+      ttl: parseInt(ttl, 10),
+      timestamp: ts,
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  MX  preference exchange
-    const [ owner, ttl, c, type, preference, exchange ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, preference, exchange] =
+      opts.bindline.split(/\s+/)
 
     return new MX({
       owner,
-      ttl       : parseInt(ttl, 10),
-      class     : c,
+      ttl: parseInt(ttl, 10),
+      class: c,
       type,
       preference: parseInt(preference),
       exchange,
@@ -76,11 +90,11 @@ export default class MX extends RR {
   }
 
   /******  EXPORTERS   *******/
-  toBind (zone_opts) {
+  toBind(zone_opts) {
     return `${this.getPrefix(zone_opts)}\t${this.get('preference')}\t${this.getFQDN('exchange', zone_opts)}\n`
   }
 
-  toTinydns () {
+  toTinydns() {
     return `@${this.getTinyFQDN('owner')}::${this.getTinyFQDN('exchange')}:${this.get('preference')}:${this.getTinydnsPostamble()}\n`
   }
 }

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()))
+      this.throwHelp(`NAPTR flags are invalid`)
 
     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(':')
-    if (n != 35) throw new Error('NAPTR fromTinydns, invalid n')
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    if (n != 35) this.throwHelp('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,15 +1,14 @@
-
 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) {
-    if (!val) throw new Error(`NS: dname is required, ${this.citeRFC()}`)
+  setDname(val) {
+    if (!val) this.throwHelp(`NS: dname is required`)
 
     this.isFullyQualified('NS', 'dname', val)
     this.isValidHostname('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`
   }
 }