@nictool/dns-resource-record 1.1.6 → 1.2.0

package/lib/tinydns.js

@@ -1,83 +1,88 @@
-
-export const SPECIALCHARS = {
-  '+': [ 'A' ],
-  '-': [ undefined ],  // disabled RR
-  '%': [ 'location' ],
-  '.': [ 'SOA', 'NS', 'A' ],
-  '&': [ 'NS', 'A' ],
-  '=': [ 'A', 'PTR' ],
-  '@': [ 'MX', 'A' ],
-  '#': [ 'comment' ],
-  "'": [ 'TXT' ],
-  '^': [ 'PTR' ],
-  'C': [ 'CNAME' ],
-  'Z': [ 'SOA' ],
-  ':': [ 'generic' ],
-  '3': [ 'AAAA' ],
-  '6': [ 'AAAA', 'PTR' ],
-  'S': [ 'SRV' ],
+export const SPECIAL_CHARS = {
+  '+': ['A'],
+  '-': [undefined], // disabled RR
+  '%': ['location'],
+  '.': ['SOA', 'NS', 'A'],
+  '&': ['NS', 'A'],
+  '=': ['A', 'PTR'],
+  '@': ['MX', 'A'],
+  '#': ['comment'],
+  "'": ['TXT'],
+  '^': ['PTR'],
+  C: ['CNAME'],
+  Z: ['SOA'],
+  ':': ['generic'],
+  3: ['AAAA'],
+  6: ['AAAA', 'PTR'],
+  S: ['SRV'],
 }
 
 const octalRe = new RegExp(/\\(?:[1-7][0-7]{0,2}|[0-7]{2,3})/, 'g')
 
-export function escapeOctal (re, str) {
+export function escapeOctal(re, str) {
   let escaped = ''
-  str.split(/(.{1})/g).map(c => {
+  str.split(/(.{1})/g).map((c) => {
     escaped += re.test(c) ? charToOctal(c) : c
   })
   return escaped
 }
 
-export function octalToChar (str) {
+export function octalToChar(str) {
   // relace instances of \NNN with ASCII
-  return str.replace(octalRe, o => String.fromCharCode(parseInt(o.substring(1), 8)))
+  return str.replace(octalRe, (o) =>
+    String.fromCharCode(parseInt(o.substring(1), 8)),
+  )
 }
 
-export function octalToHex (str) {
+export function octalToHex(str) {
   // relace instances of \NNN with Hex
-  return str.replace(octalRe, o => {
+  return str.replace(octalRe, (o) => {
     // parseInt(n, 8) -> from octal to decimal
     //  .toString(16) -> decimal to hex
     return parseInt(o.substring(1), 8).toString(16).padStart(2, 0)
   })
 }
 
-export function octalToUInt8 (str) {
+export function octalToUInt8(str) {
   const b = Buffer.alloc(1)
-  b.writeUInt8(parseInt(str.substring(1,4), 8), 0)
+  b.writeUInt8(parseInt(str.substring(1, 4), 8), 0)
   return b.readUInt8()
 }
 
-export function octalToUInt16 (str) {
+export function octalToUInt16(str) {
   const b = Buffer.alloc(2)
-  b.writeUInt8(parseInt(str.substring(1,4), 8), 0)
-  b.writeUInt8(parseInt(str.substring(5,8), 8), 1)
+  b.writeUInt8(parseInt(str.substring(1, 4), 8), 0)
+  b.writeUInt8(parseInt(str.substring(5, 8), 8), 1)
   return b.readUInt16BE()
 }
 
-export function octalToUInt32 (str) {
+export function octalToUInt32(str) {
   const b = Buffer.alloc(4)
-  b.writeUInt8(parseInt(str.substring(1,4), 8), 0)
-  b.writeUInt8(parseInt(str.substring(5,8), 8), 1)
-  b.writeUInt8(parseInt(str.substring(9,12), 8), 2)
-  b.writeUInt8(parseInt(str.substring(13,16), 8), 3)
+  b.writeUInt8(parseInt(str.substring(1, 4), 8), 0)
+  b.writeUInt8(parseInt(str.substring(5, 8), 8), 1)
+  b.writeUInt8(parseInt(str.substring(9, 12), 8), 2)
+  b.writeUInt8(parseInt(str.substring(13, 16), 8), 3)
   return b.readUInt32BE()
 }
 
-export function packString (str) {
-  return str.match(/(.{1,255})/g).map(s => {
-    const len = Buffer.alloc(1)
-    len.writeUInt8(s.length)
-    return `${UInt8toOctal(len.readUInt8(0))}${s}`
-  }).join('')
+export function packString(str) {
+  return str
+    .match(/(.{1,255})/g)
+    .map((s) => {
+      const len = Buffer.alloc(1)
+      len.writeUInt8(s.length)
+      return `${UInt8toOctal(len.readUInt8(0))}${s}`
+    })
+    .join('')
 }
 
-export function unpackString (str) {
+export function unpackString(str) {
   const asBuf = Buffer.from(octalToChar(str.toString()))
   const res = []
   let pos = 0
   let len
-  while ((len = asBuf.readUInt8(pos))) {  // encoded length byte
+  while ((len = asBuf.readUInt8(pos))) {
+    // encoded length byte
     pos++
     res.push(asBuf.slice(pos, pos + len).toString())
     pos = +(pos + len)
@@ -86,13 +91,13 @@ export function unpackString (str) {
   return res
 }
 
-export function packDomainName (fqdn) {
+export function packDomainName(fqdn) {
   const labelRegEx = new RegExp(/[^A-Za-z0-9-.]/, 'g')
 
   // RFC 1035, 3.3 Standard RRs
   // The standard wire format for DNS names. (1 octet length + octets)
   let packed = ''
-  fqdn.split('.').map(label => {
+  fqdn.split('.').map((label) => {
     if (label === undefined || !label.length) return
 
     const len = Buffer.alloc(1)
@@ -105,14 +110,14 @@ export function packDomainName (fqdn) {
   return packed
 }
 
-export function unpackDomainName (fqdn) {
-
+export function unpackDomainName(fqdn) {
   fqdn = Buffer.from(octalToChar(fqdn.toString()))
 
   const labels = []
   let pos = 0
   let len
-  while ((len = fqdn.readUInt8(pos))) {  // encoded length byte
+  while ((len = fqdn.readUInt8(pos))) {
+    // encoded length byte
     pos++
     labels.push(fqdn.slice(pos, pos + len).toString())
     pos = +(pos + len)
@@ -120,31 +125,31 @@ export function unpackDomainName (fqdn) {
   const r = `${labels.join('.')}.`
   // char position + length of last label + label length chars + null byte
   const strLen = pos + len + labels.length * 4 + 1
-  return [ r, strLen ]
+  return [r, strLen]
 }
 
-export function packHex (str) {
+export function packHex(str) {
   let r = ''
-  for (let i = 0; i < str.length; i = i+2) {
+  for (let i = 0; i < str.length; i = i + 2) {
     // nibble off 2 hex bytes, encode to octal
-    r += UInt8toOctal(parseInt(str.slice(i, i+2), 16))
+    r += UInt8toOctal(parseInt(str.slice(i, i + 2), 16))
   }
   return r
 }
 
-export function charToOctal (c) {
+export function charToOctal(c) {
   if (typeof c === 'number') return UInt8toOctal(c)
 
   return UInt8toOctal(c.charCodeAt(0))
 }
 
-export function UInt8toOctal (n) {
+export function UInt8toOctal(n) {
   if (n > 255) throw new Error('UInt8toOctal does not work on numbers > 255')
 
   return `\\${parseInt(n, 10).toString(8).padStart(3, 0)}`
 }
 
-export function UInt16toOctal (n) {
+export function UInt16toOctal(n) {
   let r = ''
   const pri = Buffer.alloc(2)
   pri.writeUInt16BE(n)
@@ -153,7 +158,7 @@ export function UInt16toOctal (n) {
   return r
 }
 
-export function UInt32toOctal (n) {
+export function UInt32toOctal(n) {
   let r = ''
   const pri = Buffer.alloc(4)
   pri.writeUInt32BE(n)
@@ -163,24 +168,26 @@ export function UInt32toOctal (n) {
   return r
 }
 
-export function ipv4toOctal (ip) {
+export function ipv4toOctal(ip) {
   return UInt32toOctal(ip.split`.`.reduce((int, value) => int * 256 + +value))
 }
 
-export function octalToIPv4 (str) {
+export function octalToIPv4(str) {
   const asInt = octalToUInt32(str)
-  return [ 24,16,8,0 ].map(n => (asInt >> n) & 0xff).join('.')
+  return [24, 16, 8, 0].map((n) => (asInt >> n) & 0xff).join('.')
 }
 
-export function base64toOctal (str) {
+export function base64toOctal(str) {
   const bytes = Buffer.from(str, 'base64')
   let escaped = ''
   for (const b of bytes) {
-    escaped += /[A-Za-z0-9\-.]/.test(String.fromCharCode(b)) ? String.fromCharCode(b) : UInt8toOctal(b)
+    escaped += /[A-Za-z0-9\-.]/.test(String.fromCharCode(b))
+      ? String.fromCharCode(b)
+      : UInt8toOctal(b)
   }
   return escaped
 }
 
-export function octalToBase64 (str) {
+export function octalToBase64(str) {
   return Buffer.from(octalToChar(str), 'binary').toString('base64')
 }

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "@nictool/dns-resource-record",
-  "version": "1.1.6",
+  "version": "1.2.0",
   "description": "DNS Resource Records",
   "main": "index.js",
   "type": "module",
   "scripts": {
-    "lint": "npx eslint *.js lib rr test",
-    "lintfix": "npx eslint --fix *.js lib rr test",
+    "format:check": "npm run prettier; npm run lint",
+    "format": "npm run prettier -- --write && npm run lint --fix",
+    "lint": "npx eslint **/*.js",
+    "lint:fix": "npm run lint -- --fix",
+    "prettier": "npx prettier --ignore-path .gitignore --check .",
+    "prettier:fix": "npx prettier --ignore-path .gitignore --write .",
     "test": "npx mocha",
-    "versions": "npx dependency-version-checker check"
+    "versions": "npx dependency-version-checker check",
+    "watch": "npm run test -- --watch"
   },
   "repository": {
     "type": "git",
@@ -34,7 +39,6 @@
   },
   "homepage": "https://github.com/NicTool/dns-resource-record#readme",
   "devDependencies": {
-    "eslint": "^8.11.0",
-    "mocha": "^9.2.2"
+    "mocha": "^10.3.0"
   }
 }

package/rr/a.js

@@ -1,57 +1,56 @@
-
 import net from 'net'
 
 import RR from '../rr.js'
 
 export default class A extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setAddress (val) {
+  setAddress(val) {
     if (!val) throw new Error('A: address is required')
     if (!net.isIPv4(val)) throw new Error('A address must be IPv4')
     this.set('address', val)
   }
 
-  getDescription () {
+  getDescription() {
     return 'Address'
   }
 
-  getRdataFields (arg) {
-    return [ 'address' ]
+  getRdataFields(arg) {
+    return ['address']
   }
 
-  getRFCs () {
-    return [ 1035 ]
+  getRFCs() {
+    return [1035]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 1
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     // +fqdn:ip:ttl:timestamp:lo
-    const [ owner, ip, ttl, ts, loc ] = opts.tinyline.substring(1).split(':')
+    const [owner, ip, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
 
     return new A({
-      owner    : this.fullyQualify(owner),
-      type     : 'A',
-      address  : ip,
-      ttl      : parseInt(ttl, 10),
+      owner: this.fullyQualify(owner),
+      type: 'A',
+      address: ip,
+      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  A  192.0.2.127
-    const [ owner, ttl, c, type, address ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, address] = opts.bindline.split(/\s+/)
     return new A({
       owner,
-      ttl  : parseInt(ttl, 10),
+      ttl: parseInt(ttl, 10),
       class: c,
       type,
       address,
@@ -59,7 +58,7 @@ export default class A extends RR {
   }
 
   /******  EXPORTERS   *******/
-  toTinydns () {
+  toTinydns() {
     return `+${this.getTinyFQDN('owner')}:${this.get('address')}:${this.getTinydnsPostamble()}\n`
   }
 }

package/rr/aaaa.js

@@ -1,86 +1,87 @@
-
 import net from 'net'
 
 import RR from '../rr.js'
 import * as TINYDNS from '../lib/tinydns.js'
 
 export default class AAAA extends RR {
-  constructor (opts) {
+  constructor(opts) {
     super(opts)
   }
 
   /****** Resource record specific setters   *******/
-  setAddress (val) {
+  setAddress(val) {
     if (!val) throw new Error('AAAA: address is required')
     if (!net.isIPv6(val)) throw new Error(`AAAA: address must be IPv6 (${val})`)
 
     this.set('address', this.expand(val.toLowerCase())) // lower case: RFC 5952
   }
 
-  getCompressed (val) {
+  getCompressed(val) {
     this.compress(val || this.get('address'))
   }
 
-  getDescription () {
+  getDescription() {
     return 'Address IPv6'
   }
 
-  getRdataFields (arg) {
-    return [ 'address' ]
+  getRdataFields(arg) {
+    return ['address']
   }
 
-  getRFCs () {
-    return [ 3596 ]
+  getRFCs() {
+    return [3596]
   }
 
-  getTypeId () {
+  getTypeId() {
     return 28
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns (opts) {
+  fromTinydns(opts) {
     const str = opts.tinyline
     let fqdn, ip, n, rdata, ttl, ts, loc
 
     switch (str[0]) {
       case ':':
         // GENERIC  =>  :fqdn:28:rdata:ttl:timestamp:lo
-        [ fqdn, n, rdata, ttl, ts, loc ] = str.substring(1).split(':')
+        ;[fqdn, n, rdata, ttl, ts, loc] = str.substring(1).split(':')
         if (n != 28) throw new Error('AAAA fromTinydns, invalid n')
-        ip = TINYDNS.octalToHex(rdata).match(/([0-9a-fA-F]{4})/g).join(':')
+        ip = TINYDNS.octalToHex(rdata)
+          .match(/([0-9a-fA-F]{4})/g)
+          .join(':')
         break
       case '3':
       case '6':
         // AAAA     =>  3fqdn:ip:x:ttl:timestamp:lo
         // AAAA,PTR =>  6fqdn:ip:x:ttl:timestamp:lo
-        [ fqdn, rdata, ttl, ts, loc ] = str.substring(1).split(':')
+        ;[fqdn, rdata, ttl, ts, loc] = str.substring(1).split(':')
         ip = rdata.match(/(.{4})/g).join(':')
         break
     }
 
     return new AAAA({
-      owner    : this.fullyQualify(fqdn),
-      ttl      : parseInt(ttl, 10),
-      type     : 'AAAA',
-      address  : ip,
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'AAAA',
+      address: ip,
       timestamp: ts,
-      location : loc !== '' && loc !== '\n' ? loc : '',
+      location: loc !== '' && loc !== '\n' ? loc : '',
     })
   }
 
-  fromBind (opts) {
+  fromBind(opts) {
     // test.example.com  3600  IN  AAAA  ...
-    const [ owner, ttl, c, type, ip ] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, ip] = opts.bindline.split(/\s+/)
     return new AAAA({
       owner,
-      ttl    : parseInt(ttl, 10),
-      class  : c,
+      ttl: parseInt(ttl, 10),
+      class: c,
       type,
       address: this.expand(ip),
     })
   }
 
-  compress (val) {
+  compress(val) {
     /*
      * RFC 5952
      * 4.1. Leading zeros MUST be suppressed...A single 16-bit 0000 field MUST be represented as 0.
@@ -88,10 +89,10 @@ export default class AAAA extends RR {
      * 4.2.2 The symbol "::" MUST NOT be used to shorten just one 16-bit 0 field.
      * 4.2.3 When choosing placement of a "::", the longest run...MUST be shortened
      * 4.3 The characters a-f in an IPv6 address MUST be represented in lowercase.
-    */
+     */
     let r = val
-      .replace(/0000/g, '0')             // 4.1 0000 -> 0
-      .replace(/:0+([1-9a-fA-F])/g, ':$1')  // 4.1 remove leading zeros
+      .replace(/0000/g, '0') // 4.1 0000 -> 0
+      .replace(/:0+([1-9a-fA-F])/g, ':$1') // 4.1 remove leading zeros
 
     const mostConsecutiveZeros = [
       new RegExp(/0?(?::0){6,}:0?/),
@@ -111,7 +112,7 @@ export default class AAAA extends RR {
     return r
   }
 
-  expand (val, delimiter) {
+  expand(val, delimiter) {
     if (delimiter === undefined) delimiter = ':'
 
     const colons = val.match(/:/g)
@@ -121,15 +122,18 @@ export default class AAAA extends RR {
     }
 
     // restore compressed leading zeros
-    return val.split(':').map(s => s.padStart(4, 0)).join(delimiter)
+    return val
+      .split(':')
+      .map((s) => s.padStart(4, 0))
+      .join(delimiter)
   }
 
   /******  EXPORTERS   *******/
-  toBind (zone_opts) {
+  toBind(zone_opts) {
     return `${this.getPrefix(zone_opts)}\t${this.compress(this.get('address'))}\n`
   }
 
-  toTinydns () {
+  toTinydns() {
     // from AAAA notation (8 groups of 4 hex digits) to 16 escaped octals
     const rdata = TINYDNS.packHex(this.expand(this.get('address'), ''))
     return this.getTinydnsGeneric(rdata)

package/rr/caa.js

@@ -1,110 +1,112 @@
-
 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)) {
+    if (![0, 128].includes(val)) {
       throw new Error(`CAA flags ${val} not recognized, ${this.citeRFC()}`)
     }
 
     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))
+      throw new Error(
+        `CAA tag must be a sequence of ASCII letters and numbers in lowercase, ${this.citeRFC()}`,
+      )
 
-    if (![ 'issue', 'issuewild', 'iodef' ].includes(val)) {
+    if (!['issue', 'issuewild', 'iodef'].includes(val)) {
       throw new Error(`CAA tag ${val} not recognized: ${this.citeRFC()}`)
     }
     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 {
+    } else {
       // if (/\s/.test(val)) throw new Error(`CAA value may not have spaces unless quoted: RFC 8659`)
     }
 
     // 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) {
+        throw new Error(
+          `CAA value must have valid iodefScheme prefix, ${this.citeRFC()}`,
+        )
       }
     }
 
     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
   }
 
   /******  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(':')
+    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
     if (n != 257) throw new Error('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)
+    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 [ 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 +117,7 @@ export default class CAA extends RR {
 
   /******  EXPORTERS   *******/
 
-  toTinydns () {
+  toTinydns() {
     let rdata = ''
     rdata += TINYDNS.UInt8toOctal(this.get('flags'))